code-coordinator 0.5.125__tar.gz → 0.5.128__tar.gz

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/CLAUDE.md

@@ -261,6 +261,7 @@ reviewer can stop reading here.
 - [`docs/GRAPHIFY_SETUP.md`](docs/GRAPHIFY_SETUP.md) — installing the knowledge graph on a new machine (four layers, all of which fail *silently*).
 - [`docs/EPHEMERAL_WORKERS.md`](docs/EPHEMERAL_WORKERS.md) — on-demand Azure worker VMs per epic. **The tailnet ACL is the security boundary** — `agent_app.py` has no authentication.
 - [`docs/MAC_MINI.md`](docs/MAC_MINI.md) — adding a Mac mini; sizing, provisioning, and what non-macOS work routes there. The port itself is [`docs/CROSS_PLATFORM.md`](docs/CROSS_PLATFORM.md) (milestone #39).
+- [`docs/WSL_WINDOWS_WORKER.md`](docs/WSL_WINDOWS_WORKER.md) — using a Tailscale-connected WSL2 box as the Windows worker for quadraui/vimcode's Win-GUI ports. Not the coord-itself Windows port.
 - [`docs/FORGE_MIGRATION.md`](docs/FORGE_MIGRATION.md) — surviving a forge outage (cheap) versus leaving a forge (expensive); milestone #58 / epic #1902.
 
 **Two deploy facts that bite most often:**

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.125
+Version: 0.5.128
 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.125 → code_coordinator-0.5.128}/code_coordinator.egg-info/SOURCES.txt

@@ -389,6 +389,7 @@ docs/SECOND_BACKEND.md
 docs/STORE_SERVICE.md
 docs/TEST_FIRST_BUG_LANE.md
 docs/WEB_CONTROL_CENTER.md
+docs/WSL_WINDOWS_WORKER.md
 docs/mocks/web/README.md
 docs/mocks/web/_tokens.css
 docs/mocks/web/issue-detail.html
@@ -827,6 +828,7 @@ tui/src/app/audit.rs
 tui/src/app/chat.rs
 tui/src/app/data.rs
 tui/src/app/dialogs.rs
+tui/src/app/doc_tabs.rs
 tui/src/app/drive.rs
 tui/src/app/drive_queue.rs
 tui/src/app/escalation.rs

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/code_coordinator.egg-info/scm_file_list.json

@@ -367,6 +367,7 @@
     "docs/STORE_SERVICE.md",
     "docs/TEST_FIRST_BUG_LANE.md",
     "docs/WEB_CONTROL_CENTER.md",
+    "docs/WSL_WINDOWS_WORKER.md",
     "docs/mocks/web/README.md",
     "docs/mocks/web/_tokens.css",
     "docs/mocks/web/issue-detail.html",
@@ -803,6 +804,7 @@
     "tui/src/app/chat.rs",
     "tui/src/app/data.rs",
     "tui/src/app/dialogs.rs",
+    "tui/src/app/doc_tabs.rs",
     "tui/src/app/drive.rs",
     "tui/src/app/drive_queue.rs",
     "tui/src/app/escalation.rs",

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.125",
+  "tag": "0.5.128",
   "distance": 0,
-  "node": "g45b284e5f4bdc6047cbd9db9e0a0d4f1c11ca154",
+  "node": "gdb3e5a50ffe1a0bb743d2cc2f791188761858441",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/coord/block_log.py

@@ -70,7 +70,9 @@ from typing import Any
 
 from coord.drive_queue import (
     STATE_BLOCKED,
+    STATE_DONE,
     STATE_PARKED,
+    STATE_WAITING,
     QueueEntry,
     TickPlan,
 )
@@ -107,6 +109,8 @@ __all__ = [
     "episodes",
     "is_by_design",
     "log_location",
+    "merge_only_event",
+    "merge_only_fallback_event",
     "operator_resolution_event",
     "plan_events",
     "read_events",
@@ -221,6 +225,20 @@ _LANDED_CAUSE = (
     "already-landed — the work merged or closed while the entry sat in this "
     "state, so the stated reason had outlived the thing it described"
 )
+#: #2350: distinct from `_LANDED_CAUSE` on purpose — that one means "the entry
+#: sat here and something ELSE finished it while nobody was looking" (a human,
+#: an unrelated branch merge, `coord reconcile-merges`); this one means the
+#: QUEUE ITSELF, this same tick, ran `coord merge --only` and landed it —
+#: see `coord.commands.drive_queue._run_merge_only_candidates`'s success
+#: branch, the ONLY writer of the `outcome == "merged"` `_resolve_record`
+#: reads to pick this cause. Conflating the two into one `auto-released`-style
+#: bucket is exactly what #2350 was written to stop: #2235's corpus needs to
+#: tell "the mechanism did this" apart from "the state flipped and something
+#: unrelated did it".
+_AUTO_MERGED_CAUSE = (
+    "auto-merged — the queue completed the merge directly from the tick "
+    "(#2350), Test/Review already satisfied; Merge was the only gate left"
+)
 _OPERATOR_CAUSE = (
     "operator-intervened — no automatic release fired; a human cleared it by "
     "hand, and what they actually fixed is NOT recorded here"
@@ -405,7 +423,17 @@ def _resolve_record(
     now: float,
     outcome: str,
 ) -> dict[str, Any]:
-    if outcome == "done" or new_state == "done":
+    if outcome == "merged":
+        # #2350: checked BEFORE the "done" branch below — a successful
+        # Merge-only fast-path attempt also lands `new_state == "done"` (it
+        # skips the `waiting`/relaunch cycle entirely), so without this
+        # ordering the generic landed check would win the match and this
+        # episode would be indistinguishable from "something else merged it
+        # while it sat here" — exactly the conflation #2350 exists to split
+        # out of #2230's `auto-released`/#2055's `already-landed`.
+        true_cause, human = _AUTO_MERGED_CAUSE, False
+        resolution = "auto_merged"
+    elif outcome == "done" or new_state == "done":
         true_cause, human = _LANDED_CAUSE, False
         resolution = "landed"
     elif outcome == "resumed":
@@ -471,6 +499,81 @@ def enter_event(
     return record
 
 
+def merge_only_event(
+    entry: QueueEntry,
+    *,
+    host: str = "",
+    now: float | None = None,
+) -> dict[str, Any]:
+    """The ``resolve`` record for #2350's Merge-only fast path.
+
+    The other caller-constructed record besides :func:`enter_event`, and for
+    the identical structural reason: the transition happens OUTSIDE
+    :func:`plan_events`'s view. A `merge_only` :class:`~coord.drive_queue.
+    Reconcile` deliberately writes no `state` (see its docstring), so
+    `plan.writes()` never carries the `parked`/`blocked` → `done` move this
+    function records — it only happens once the shell's own live
+    ``coord merge --only`` attempt reports success, strictly after
+    ``_apply_writes`` has already run for the rest of the tick. *entry* is
+    the PRE-tick snapshot (its ``state`` is still `parked`/`blocked`); the
+    entry has already landed by the time this is called, so `new_state` is
+    unconditionally :data:`~coord.drive_queue.STATE_DONE`.
+    """
+    stamp = time.time() if now is None else now
+    record = _resolve_record(
+        entry.key,
+        entry.state,
+        STATE_DONE,
+        "",
+        entry,
+        host=host,
+        now=stamp,
+        outcome="merged",
+    )
+    record["source"] = "tick"
+    return record
+
+
+def merge_only_fallback_event(
+    entry: QueueEntry,
+    *,
+    reason: str,
+    host: str = "",
+    now: float | None = None,
+) -> dict[str, Any]:
+    """The ``resolve`` record for #2350's Merge-only fast path RACE case:
+    the live gate read clear enough to attempt a direct merge, but the
+    attempt itself did not confirm a landed merge, so
+    ``coord.commands.drive_queue._run_merge_only_candidates`` falls back to
+    exactly the pre-#2350 ``resumed`` shape (``STATE_WAITING``) — OUTSIDE
+    ``plan.writes()``, the same reason :func:`merge_only_event` exists for
+    the success case: without this, the episode :func:`plan_events` already
+    opened for *entry* would never see a matching close, and
+    ``coord drive-queue block-log`` would show it stuck ``(unresolved)``
+    forever even though the entry plainly left `parked`/`blocked` this tick.
+
+    Classified as an ordinary ``resumed`` outcome — not a new #2350 cause —
+    on purpose: unlike the success case, this genuinely IS "state flipped,
+    cause a plain gate re-clear" (:func:`_resume_cause`'s fallback,
+    ``auto-released``), the same honest non-answer a bare board-signal
+    resume already gets. #2350's distinct cause is reserved for the tick
+    actually landing the merge itself.
+    """
+    stamp = time.time() if now is None else now
+    record = _resolve_record(
+        entry.key,
+        entry.state,
+        STATE_WAITING,
+        reason,
+        entry,
+        host=host,
+        now=stamp,
+        outcome="resumed",
+    )
+    record["source"] = "tick"
+    return record
+
+
 def operator_resolution_event(
     entry: QueueEntry,
     *,

{code_coordinator-0.5.125 → code_coordinator-0.5.128}/coord/commands/acceptance.py

@@ -420,6 +420,37 @@ def _acceptance_worktree_path(repo_name: str, issue_number: int) -> Path:
     return COORD_DIR / "acceptance-worktrees" / f"{repo_name}-{issue_number}"
 
 
+def _acceptance_worktree_lock_path(repo_name: str, issue_number: int) -> Path:
+    """The ``flock`` guarding :func:`_acceptance_worktree_path` (#2352).
+
+    That path is deliberately ONE per ``(repo, issue)``, reused across every
+    SHA/round for that issue (same incremental-build rationale as `coord
+    test`'s #561) — but nothing serialised *access* to it. Two concurrent
+    ``coord acceptance record`` calls for the same issue (an orphaned drive
+    process — #1660 — racing a fresh queue relaunch, or a by-hand re-run
+    overlapping an in-flight one) each did an unconditional ``git worktree
+    remove --force`` + ``add --force`` on the SAME directory: the second
+    invocation's remove ripped the tree out from under the first's
+    in-flight build/test, mid-compile. The corrupted build then printed
+    ordinary-looking compiler errors and exited non-zero having run zero
+    tests — indistinguishable from a genuinely red suite to
+    ``_scoped_verdict``, so it landed on the board as a real
+    ``acceptance_state=failed`` and burned a drive's fix-round budget on a
+    PR that was never actually broken.
+
+    A sibling ``.lock`` file next to the worktree directory itself (not one
+    global lock for the whole ``acceptance-worktrees/`` tree) so unrelated
+    ``(repo, issue)`` pairs never wait on each other.
+
+    Derived from :func:`_acceptance_worktree_path` (module-level lookup, so
+    a test monkeypatching that name — e.g. to redirect it under
+    ``tmp_path`` — redirects this lock alongside it) rather than
+    re-deriving ``COORD_DIR`` independently, which would silently drift the
+    two apart the moment either one's path scheme changes."""
+    wt_path = _acceptance_worktree_path(repo_name, issue_number)
+    return wt_path.with_name(wt_path.name + ".lock")
+
+
 def _remove_acceptance_worktree(repo_dir: Path, wt_path: Path) -> None:
     if not wt_path.exists():
         return
@@ -819,6 +850,7 @@ def _acceptance_record_local(
     config_path: Path,
     route_path: str | None = None,
 ) -> None:
+    from coord.filelock import FileLock  # noqa: PLC0415
     from coord.test_orchestrator import find_local_repo_path  # noqa: PLC0415
 
     cfg = _load_config(config_path)
@@ -835,119 +867,140 @@ def _acceptance_record_local(
         sys.exit(1)
 
     wt_path = _acceptance_worktree_path(repo, issue_number)
-    click.echo(
-        f"Fetching origin and preparing acceptance worktree at {sha!r} "
-        f"(base checkout {repo_dir} stays untouched)..."
-    )
-    try:
-        subprocess.run(
-            ["git", "fetch", "origin", "--prune"], cwd=str(repo_dir),
-            check=True, capture_output=True, text=True,
-        )
-    except subprocess.CalledProcessError as e:
-        click.echo(f"error: git fetch failed: {e.stderr.strip()}", err=True)
-        sys.exit(1)
 
-    _remove_acceptance_worktree(repo_dir, wt_path)
-    wt_path.parent.mkdir(parents=True, exist_ok=True)
-    res = subprocess.run(
-        ["git", "worktree", "add", "--force", "--detach", str(wt_path), sha],
-        cwd=str(repo_dir), capture_output=True, text=True,
-    )
-    if res.returncode != 0:
+    # #2352: everything from here down touches the ONE worktree this
+    # (repo, issue) reuses across every SHA/round — remove+add it, build in
+    # it, read its results. A second concurrent `coord acceptance record`
+    # for the same issue (an orphaned drive racing a fresh queue relaunch,
+    # or a by-hand re-run overlapping an in-flight one — see
+    # _acceptance_worktree_lock_path's docstring) must never interleave
+    # with this, or its `git worktree remove --force` clobbers whatever the
+    # first invocation is mid-build on. Blocking (not fail-fast) is
+    # deliberate: `flock` is released by the kernel even if the holder is
+    # killed, so there is no stale-lock deadlock risk to trade away, and
+    # blocking needs no change to `_decide_acceptance_gate`'s error
+    # handling — the second invocation just waits its turn and then records
+    # its own (correct) verdict, same as if it had been dispatched later.
+    with FileLock(_acceptance_worktree_lock_path(repo, issue_number)):
         click.echo(
-            f"error: could not create acceptance worktree at {sha!r}: "
-            f"{res.stderr.strip()}",
-            err=True,
+            f"Fetching origin and preparing acceptance worktree at {sha!r} "
+            f"(base checkout {repo_dir} stays untouched)..."
         )
-        sys.exit(1)
-
-    # #1125 review finding 2: resolve `{ms}` from the issue's manifest-mapped
-    # ms-NN dir (the worktree just checked out at `sha`) before running —
-    # same fail-soft-to-None rationale as `acceptance_run` above.
-    ms: str | None = None
-    try:
-        ms = ms_dir_for_issue(wt_path / ACCEPTANCE_DIRNAME, issue_number)
-    except Exception:  # noqa: BLE001
-        ms = None
+        try:
+            subprocess.run(
+                ["git", "fetch", "origin", "--prune"], cwd=str(repo_dir),
+                check=True, capture_output=True, text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            click.echo(f"error: git fetch failed: {e.stderr.strip()}", err=True)
+            sys.exit(1)
 
-    try:
-        result = run_driver(
-            driver_cfg.kind, driver_cfg.run, cwd=str(wt_path), ms=ms,
-            setup_command=driver_cfg.setup,
-        )
-    except DriverError as e:
-        click.echo(f"error: {e}", err=True)
         _remove_acceptance_worktree(repo_dir, wt_path)
-        sys.exit(1)
-
-    # #944 review: _scoped_verdict exits(1) internally for a manifest that
-    # hasn't been authored yet / has no slice for this issue — a
-    # configuration error, not a real (kept-for-inspection) test failure, so
-    # the throwaway worktree must still be cleaned up on the way out.
-    try:
-        verdict = _scoped_verdict(
-            result.tests, wt_path / ACCEPTANCE_DIRNAME, issue_number,
-            entrypoint=driver_cfg.entrypoint,
+        wt_path.parent.mkdir(parents=True, exist_ok=True)
+        res = subprocess.run(
+            ["git", "worktree", "add", "--force", "--detach", str(wt_path), sha],
+            cwd=str(repo_dir), capture_output=True, text=True,
         )
-    except SystemExit:
-        _remove_acceptance_worktree(repo_dir, wt_path)
-        raise
+        if res.returncode != 0:
+            click.echo(
+                f"error: could not create acceptance worktree at {sha!r}: "
+                f"{res.stderr.strip()}",
+                err=True,
+            )
+            sys.exit(1)
 
-    from coord.board_service import read_board  # noqa: PLC0415
-    from coord.diagnose import stage_assignments  # noqa: PLC0415
+        # #1125 review finding 2: resolve `{ms}` from the issue's
+        # manifest-mapped ms-NN dir (the worktree just checked out at
+        # `sha`) before running — same fail-soft-to-None rationale as
+        # `acceptance_run` above.
+        ms: str | None = None
+        try:
+            ms = ms_dir_for_issue(wt_path / ACCEPTANCE_DIRNAME, issue_number)
+        except Exception:  # noqa: BLE001
+            ms = None
 
-    board = read_board()
-    work_rows = stage_assignments(board, repo, issue_number, "work")
-    if not work_rows:
-        click.echo(
-            f"error: no work assignment found for {repo} #{issue_number}; "
-            "cannot record verdict",
-            err=True,
-        )
-        # Same rationale: a lookup error, not a failing-verdict "kept for
-        # inspection" case — don't leak the worktree.
-        _remove_acceptance_worktree(repo_dir, wt_path)
-        sys.exit(1)
-    assignment_id = work_rows[0].assignment_id
-
-    from coord.state import record_acceptance_verdict  # noqa: PLC0415
-
-    acceptance_state = "passed" if verdict["green"] else "failed"
-    reason = failure_summary(verdict) or None
-    record_acceptance_verdict(
-        assignment_id=assignment_id,
-        acceptance_state=acceptance_state,
-        acceptance_reason=reason,
-        acceptance_sha=sha,
-        # #932: per-test counts so the Acceptance box can show partial
-        # progress ("3/7 acceptance green") instead of a bare verdict.
-        acceptance_total=verdict["total"],
-        acceptance_passed=verdict["passed"],
-    )
+        try:
+            result = run_driver(
+                driver_cfg.kind, driver_cfg.run, cwd=str(wt_path), ms=ms,
+                setup_command=driver_cfg.setup,
+            )
+        except DriverError as e:
+            click.echo(f"error: {e}", err=True)
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            sys.exit(1)
 
-    click.echo(json.dumps(verdict, indent=2))
-    click.echo(f"\nAcceptance {acceptance_state.upper()} for {repo} #{issue_number} @ {sha}")
-
-    if acceptance_state == "passed":
-        # #2164 review: clearing expected_red here (before Test/Review/the
-        # actual merge to the default branch have happened) was the bug —
-        # it could reopen "red default branch" for reasons unrelated to
-        # whatever CI run next observed this issue's still-unmerged fix.
-        # The clear now happens in `coord.merge_queue.process`, right after
-        # this SHA's PR actually merges — see
-        # `coord.acceptance.clear_expected_red_via_pr`'s docstring. Nothing
-        # to do here beyond pointing the operator at how to check.
-        if ms is not None:
+        # #944 review: _scoped_verdict exits(1) internally for a manifest
+        # that hasn't been authored yet / has no slice for this issue — a
+        # configuration error, not a real (kept-for-inspection) test
+        # failure, so the throwaway worktree must still be cleaned up on
+        # the way out.
+        try:
+            verdict = _scoped_verdict(
+                result.tests, wt_path / ACCEPTANCE_DIRNAME, issue_number,
+                entrypoint=driver_cfg.entrypoint,
+            )
+        except SystemExit:
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            raise
+
+        from coord.board_service import read_board  # noqa: PLC0415
+        from coord.diagnose import stage_assignments  # noqa: PLC0415
+
+        board = read_board()
+        work_rows = stage_assignments(board, repo, issue_number, "work")
+        if not work_rows:
             click.echo(
-                f"  note: any expected_red entries for #{issue_number} clear "
-                f"automatically once its fix merges — see `coord acceptance "
-                f"expected-red {repo}` to check current state."
+                f"error: no work assignment found for {repo} #{issue_number}; "
+                "cannot record verdict",
+                err=True,
             )
-        _remove_acceptance_worktree(repo_dir, wt_path)
-    else:
-        click.echo(f"  worktree kept for inspection: {wt_path}")
-        sys.exit(1)
+            # Same rationale: a lookup error, not a failing-verdict "kept
+            # for inspection" case — don't leak the worktree.
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            sys.exit(1)
+        assignment_id = work_rows[0].assignment_id
+
+        from coord.state import record_acceptance_verdict  # noqa: PLC0415
+
+        acceptance_state = "passed" if verdict["green"] else "failed"
+        reason = failure_summary(verdict) or None
+        record_acceptance_verdict(
+            assignment_id=assignment_id,
+            acceptance_state=acceptance_state,
+            acceptance_reason=reason,
+            acceptance_sha=sha,
+            # #932: per-test counts so the Acceptance box can show partial
+            # progress ("3/7 acceptance green") instead of a bare verdict.
+            acceptance_total=verdict["total"],
+            acceptance_passed=verdict["passed"],
+        )
+
+        click.echo(json.dumps(verdict, indent=2))
+        click.echo(
+            f"\nAcceptance {acceptance_state.upper()} for {repo} #{issue_number} @ {sha}"
+        )
+
+        if acceptance_state == "passed":
+            # #2164 review: clearing expected_red here (before
+            # Test/Review/the actual merge to the default branch have
+            # happened) was the bug — it could reopen "red default branch"
+            # for reasons unrelated to whatever CI run next observed this
+            # issue's still-unmerged fix. The clear now happens in
+            # `coord.merge_queue.process`, right after this SHA's PR
+            # actually merges — see
+            # `coord.acceptance.clear_expected_red_via_pr`'s docstring.
+            # Nothing to do here beyond pointing the operator at how to
+            # check.
+            if ms is not None:
+                click.echo(
+                    f"  note: any expected_red entries for #{issue_number} clear "
+                    f"automatically once its fix merges — see `coord acceptance "
+                    f"expected-red {repo}` to check current state."
+                )
+            _remove_acceptance_worktree(repo_dir, wt_path)
+        else:
+            click.echo(f"  worktree kept for inspection: {wt_path}")
+            sys.exit(1)
 
 
 def _stall_push_wip_snapshot(cwd: Path) -> str: