code-coordinator 0.5.578__tar.gz → 0.5.580__tar.gz

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/PKG-INFO

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

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

@@ -70,6 +70,7 @@ coord/deploy_units.py
 coord/deprecation_telemetry.py
 coord/deps.py
 coord/diagnose.py
+coord/dirlink.py
 coord/dispatch.py
 coord/dispatch_liveness.py
 coord/dist_name.py
@@ -619,6 +620,7 @@ tests/test_deploy_web_unit.py
 tests/test_deprecation_telemetry.py
 tests/test_deps.py
 tests/test_diagnose.py
+tests/test_dirlink.py
 tests/test_dispatch.py
 tests/test_dispatch_liveness.py
 tests/test_dispatch_target_validation.py

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/code_coordinator.egg-info/scm_file_list.json

@@ -132,6 +132,7 @@
     "coord/deprecation_telemetry.py",
     "coord/deps.py",
     "coord/diagnose.py",
+    "coord/dirlink.py",
     "coord/dispatch.py",
     "coord/dispatch_liveness.py",
     "coord/dist_name.py",
@@ -646,6 +647,7 @@
     "tests/test_deprecation_telemetry.py",
     "tests/test_deps.py",
     "tests/test_diagnose.py",
+    "tests/test_dirlink.py",
     "tests/test_dispatch.py",
     "tests/test_dispatch_liveness.py",
     "tests/test_dispatch_target_validation.py",

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.578",
+  "tag": "0.5.580",
   "distance": 0,
-  "node": "g27497ebf63627571d2a865a710e3c9c502a8053d",
+  "node": "gd3b3a8b69209767b94d3b03aeea8d17b2a32d9f9",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/coord/agent.py

@@ -634,8 +634,31 @@ def _maybe_bash_wrap(argv: list[str], enabled: bool) -> list[str]:
     stdin pipe, and process-group kills all behave identically to a bare
     spawn. This is the upstream headline fix for the daemon-spawn freeze
     (anthropics/claude-code#56268). When disabled, the bare argv is returned.
+
+    #2843: a no-op on win32 regardless of *enabled*. `bash_wrap_spawn`
+    defaults to ``True`` (``ConcurrencyConfig.bash_wrap_spawn`` /
+    ``AgentServer.__init__``'s own default) with no platform guard anywhere
+    upstream of this call, so every assignment on a win32 agent — including
+    every fixture across ``tests/test_agent*.py`` that never explicitly sets
+    ``bash_wrap_spawn=False`` — silently routed through here. Two independent
+    reasons this must not reach a real ``bash`` on win32, not one:
+    (1) a POSIX shell is not guaranteed present at all (no shell, no
+    worktree-isolation guarantee the wrap exists to provide); and (2) even
+    where one IS present (Git for Windows' bundled MSYS bash on the
+    `windows-latest` runner), its `exec` builtin does not replace the process
+    image for a native (non-Cygwin/MSYS) executable the way POSIX `exec()`
+    does — so the "same PID, process-group kills behave identically to a
+    bare spawn" invariant this whole mitigation depends on does not hold,
+    and wrapping would be actively wrong there, not merely unavailable.
+    Measured root cause of the W11 cluster (#2843, child of #2680): the
+    worker process never spawned (or spawned under a PID the reaper's
+    bookkeeping didn't expect), so `_reap` observed a failure shape and the
+    assignment landed FAILED where every one of these tests expects
+    DONE/ADVISORY/REFUSED_*. This is a platform-assumption bug in THIS
+    function, not a process-group/Job-Objects runtime dependency — #1163
+    (CP-7, Job Objects) is unrelated and not needed to fix it.
     """
-    if not enabled:
+    if not enabled or sys.platform == "win32":
         return argv
     return ["bash", "-c", "exec " + shlex.join(argv)]
 

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/coord/agent_update.py

@@ -13,11 +13,16 @@ An update must be all-or-nothing.
 The fix: never write into the venv that's live. Install the target version
 into a **fresh** venv — one of two fixed "slots" next to the live one
 (``~/.coord-venv.blue`` / ``~/.coord-venv.green``) — smoke-check it, and
-only then flip a symlink so ``~/.coord-venv`` always resolves to one
-*complete* slot, old or new, never a mix. Rename of a symlink onto an
-existing path is atomic on POSIX (same filesystem), so any `coord`
-invocation racing the flip sees either the fully-old or the fully-new
-install — there is no observable in-between state.
+only then flip a directory link (see :mod:`coord.dirlink`) so
+``~/.coord-venv`` always resolves to one *complete* slot, old or new, never
+a mix. Rename of a symlink onto an existing path is atomic on POSIX (same
+filesystem), so any `coord` invocation racing the flip sees either the
+fully-old or the fully-new install — there is no observable in-between
+state. #2842: POSIX uses a symlink for exactly that atomicity guarantee;
+win32 has no directory-reparse-point equivalent of an atomic rename-over,
+so there the flip is best-effort (old link removed, new one renamed in
+immediately after) rather than a silent single-platform fiction — see
+:mod:`coord.dirlink` for the full reasoning.
 
 Using exactly two named slots (rather than a fresh directory per release)
 also gives rollback for free: the slot that was live before the swap is
@@ -86,6 +91,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from coord import restart_cmd
+from coord.dirlink import is_dir_link, make_dir_link, read_dir_link, replace_dir_link
 from coord.platform_paths import venv_exe, venv_pip, venv_python
 
 _log = logging.getLogger(__name__)
@@ -391,23 +397,24 @@ def current_slot(venv_dir: Path) -> Path | None:
     way, since ``install-agent.sh`` creates ``~/.coord-venv`` as a real
     directory.
     """
-    if not venv_dir.is_symlink():
+    if not is_dir_link(venv_dir):
         return None
-    target = venv_dir.readlink()
+    target = read_dir_link(venv_dir)
     if not target.is_absolute():
         target = (venv_dir.parent / target).resolve()
     return target
 
 
 def ensure_symlink_layout(venv_dir: Path) -> Path:
-    """Migrate *venv_dir* to the blue/green symlink layout if it isn't already.
-
-    Idempotent: if *venv_dir* is already a symlink, just returns its current
-    target. Otherwise renames the existing plain directory into the
-    ``.blue`` slot and replaces *venv_dir* with a symlink pointing at it.
-    This is the one-time, one-machine migration every pre-#1241 install
-    needs; every update after that stays in the symlink layout, so this
-    becomes a no-op for the rest of that machine's life.
+    """Migrate *venv_dir* to the blue/green link layout if it isn't already.
+
+    Idempotent: if *venv_dir* is already a directory link (a symlink on
+    POSIX, a junction on win32 — see :mod:`coord.dirlink`), just returns
+    its current target. Otherwise renames the existing plain directory
+    into the ``.blue`` slot and replaces *venv_dir* with a link pointing at
+    it. This is the one-time, one-machine migration every pre-#1241
+    install needs; every update after that stays in the link layout, so
+    this becomes a no-op for the rest of that machine's life.
     """
     existing = current_slot(venv_dir)
     if existing is not None:
@@ -418,13 +425,13 @@ def ensure_symlink_layout(venv_dir: Path) -> Path:
     if blue.exists():
         # Should be unreachable — `blue`/`green` only ever come into being
         # via this function or `perform_update`, both gated on `venv_dir`
-        # not already being a symlink. Refuse rather than clobber whatever
-        # is there.
+        # not already being a directory link. Refuse rather than clobber
+        # whatever is there.
         raise FileExistsError(
             f"{blue} already exists — refusing to migrate {venv_dir} over it"
         )
     venv_dir.rename(blue)
-    venv_dir.symlink_to(blue, target_is_directory=True)
+    make_dir_link(venv_dir, blue)
     return blue
 
 
@@ -517,20 +524,18 @@ def running_slot(venv_dir: Path) -> Path | None:
 
 
 def _atomic_swap(venv_dir: Path, new_slot: Path) -> None:
-    """Flip *venv_dir* to point at *new_slot* in one filesystem operation.
-
-    Builds the new symlink at a temp path next to *venv_dir* and renames it
-    directly onto *venv_dir* — ``rename()`` replacing an existing path is
-    atomic on POSIX when both are on the same filesystem (true here: both
-    are siblings under the same parent directory), so any `coord`
-    invocation racing this always sees either the old, complete slot or the
-    new, complete slot — never a half-updated ``venv_dir``.
+    """Flip *venv_dir* to point at *new_slot*.
+
+    Delegates to :func:`coord.dirlink.replace_dir_link`: atomic on POSIX
+    (a symlink `rename()` onto an existing path is a single filesystem
+    operation there, so any `coord` invocation racing this always sees
+    either the old, complete slot or the new, complete slot — never a
+    half-updated ``venv_dir``) and best-effort on win32, where a directory
+    junction has no equivalent single-syscall replace (#2842) — see that
+    module's docstring for the platform difference this does *not* paper
+    over.
     """
-    tmp_link = venv_dir.parent / f".{venv_dir.name}.next-link"
-    if tmp_link.is_symlink() or tmp_link.exists():
-        tmp_link.unlink()
-    tmp_link.symlink_to(new_slot, target_is_directory=True)
-    tmp_link.replace(venv_dir)
+    replace_dir_link(venv_dir, new_slot)
 
 
 def _smoke_check(slot: Path, *, target_version: str | None) -> tuple[bool, str | None, str]:

code_coordinator-0.5.580/coord/dirlink.py

@@ -0,0 +1,124 @@
+"""Cross-platform directory links: symlinks on POSIX, junctions on win32 (#2842).
+
+``coord.agent_update``'s blue/green venv swap used to call
+``Path.symlink_to``/``Path.readlink``/``Path.is_symlink`` directly, which is
+POSIX-correct but breaks two ways on win32:
+
+1. **Creating a directory symlink needs a privilege** most installs don't
+   have (Developer Mode or ``SeCreateSymbolicLinkPrivilege``) — relying on it
+   is not portable even when it happens to be available on a given box.
+2. **Replacing an existing directory symlink via ``os.replace``/
+   ``Path.replace`` fails outright** with ``[WinError 5] Access is denied``.
+   The POSIX guarantee that ``rename(2)`` atomically replaces a symlink has
+   no direct win32 equivalent for directory reparse points.
+
+The portable substitute is a **directory junction**
+(``_winapi.CreateJunction``, the same thing ``mklink /J`` produces), which
+needs no special privilege. This is the identical substitution #1163 (CP-7)
+already names for the git-worktree symlink problem — so this module is
+intentionally generic (it knows nothing about venvs or worktrees) and
+*both* call sites should route through it rather than each growing their
+own win32 branch. :mod:`coord.agent_update` is the first consumer; #1163's
+worktree-junction work should become the second rather than reinventing
+this.
+
+Junctions are not atomically swappable the way a POSIX symlink rename is —
+there is no win32 "replace this directory reparse point with that one in
+one syscall" primitive — so :func:`replace_dir_link` is atomic on POSIX
+(same guarantee ``coord.agent_update`` already documents) and best-effort
+on win32: the old link is removed (not its target — see
+:func:`remove_dir_link`) and the new one renamed into place immediately
+after, which leaves a sub-millisecond window with no link rather than no
+atomicity guarantee at all. That is a real, documented platform difference,
+not a silent gap: see ``coord.agent_update._atomic_swap``.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def make_dir_link(link_path: Path, target: Path) -> None:
+    """Create a directory link at *link_path* pointing at *target*.
+
+    POSIX: a directory symlink (``Path.symlink_to``). win32: a directory
+    junction (``_winapi.CreateJunction``), which — unlike a Windows
+    symlink — needs no Developer Mode / ``SeCreateSymbolicLinkPrivilege``.
+    """
+    if sys.platform == "win32":
+        import _winapi  # noqa: PLC0415 -- win32-only stdlib module
+
+        _winapi.CreateJunction(str(target), str(link_path))
+    else:
+        link_path.symlink_to(target, target_is_directory=True)
+
+
+def remove_dir_link(link_path: Path) -> None:
+    """Remove the link itself at *link_path* — never the directory it
+    points at.
+
+    POSIX: ``Path.unlink()`` on a symlink removes the link, not its
+    target. win32: a junction is a reparse point on an otherwise-empty
+    directory entry, removed with ``Path.rmdir()`` rather than
+    ``shutil.rmtree`` — a recursive ``rmtree`` would be wrong here since a
+    junction is transparent to many APIs, and could walk straight through
+    it into the target and delete *its* contents instead of just the link.
+    """
+    if sys.platform == "win32":
+        link_path.rmdir()
+    else:
+        link_path.unlink()
+
+
+def is_dir_link(path: Path) -> bool:
+    """Whether *path* is a directory link this module manages.
+
+    A symlink on POSIX; a symlink *or* a junction on win32 — both are
+    reparse points, and :func:`make_dir_link` only ever produces a
+    junction there, but a pre-existing or hand-made symlink should still
+    be recognized rather than silently mishandled.
+    """
+    if path.is_symlink():
+        return True
+    if sys.platform == "win32":
+        is_junction = getattr(path, "is_junction", None)
+        if is_junction is not None:
+            return is_junction()
+    return False
+
+
+def read_dir_link(link_path: Path) -> Path:
+    """Return the literal target *link_path* was created pointing at.
+
+    ``Path.readlink()`` resolves junctions as well as symlinks on win32
+    (support landed in CPython 3.8), so one call covers both platforms.
+    """
+    return link_path.readlink()
+
+
+def replace_dir_link(link_path: Path, target: Path) -> None:
+    """Flip *link_path* to point at *target*, replacing whatever (if
+    anything) is there.
+
+    Builds the new link at a temp path next to *link_path* first, so a
+    failure constructing it never touches the existing link. Atomic on
+    POSIX — the temp link is ``rename()``d directly onto *link_path*,
+    which POSIX guarantees replaces an existing path (symlink or
+    otherwise) in one filesystem operation when both are on the same
+    filesystem (true here: siblings under the same parent). Best-effort on
+    win32 — there is no equivalent single-syscall replace for a directory
+    reparse point, so the old link is removed and the new one renamed into
+    place immediately after; see the module docstring.
+    """
+    tmp_link = link_path.parent / f".{link_path.name}.next-link"
+    if is_dir_link(tmp_link) or tmp_link.exists():
+        remove_dir_link(tmp_link) if is_dir_link(tmp_link) else tmp_link.unlink()
+    make_dir_link(tmp_link, target)
+
+    if sys.platform == "win32":
+        if is_dir_link(link_path):
+            remove_dir_link(link_path)
+        tmp_link.rename(link_path)
+    else:
+        tmp_link.replace(link_path)

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/tests/test_agent.py

@@ -576,6 +576,27 @@ def test_assign_unknown_binary_marks_failed(tmp_path: Path) -> None:
     assert final.error is not None
 
 
+# #2843: `_maybe_bash_wrap`'s whole `enabled=True` branch spawns a real
+# `bash -c 'exec ...'` parent — a POSIX shell with POSIX `exec()` semantics
+# (process-image replacement, same PID). On win32 this is now a deliberate
+# no-op (see `_maybe_bash_wrap`'s own docstring): bash isn't guaranteed
+# present, and Git for Windows' bundled MSYS bash doesn't give the
+# same-PID/process-group invariant this mitigation depends on even when it
+# is. The tests marked with this skip exist specifically to exercise that
+# POSIX-only wrapping, so they skip on win32 rather than assert a behavior
+# the fix deliberately disables there — root cause and measurement in
+# #2843 (W11, child of #2680).
+_bash_wrap_posix_only = pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="exercises _maybe_bash_wrap's real bash -c 'exec ...' wrapping, "
+    "which coord/agent.py now no-ops on win32 (#2843) — bash isn't "
+    "guaranteed present, and where it is (Git for Windows' MSYS bash) its "
+    "exec builtin doesn't preserve the PID/process-group invariant this "
+    "mitigation depends on",
+)
+
+
+@_bash_wrap_posix_only
 def test_assign_unknown_binary_bash_wrapped_marks_failed(tmp_path: Path) -> None:
     """With the bash-wrap on, an unknown binary fails via bash exec's non-zero
     exit (#299) — the assignment still ends up FAILED."""
@@ -626,6 +647,7 @@ def test_inject_message_writes_to_worker_stdin(tmp_path: Path) -> None:
     assert "# inject: second message" in log, "inject marker missing from log"
 
 
+@_bash_wrap_posix_only
 def test_maybe_bash_wrap_helper() -> None:
     """The pure wrap helper produces bash -c 'exec ...' when enabled (#299)."""
     from coord.agent import _maybe_bash_wrap
@@ -636,6 +658,28 @@ def test_maybe_bash_wrap_helper() -> None:
     assert wrapped == ["bash", "-c", "exec claude -p --allowedTools Read,Bash"]
 
 
+def test_maybe_bash_wrap_is_a_noop_on_win32(monkeypatch) -> None:
+    """#2843: the whole point of the fix, pinned platform-independently.
+
+    `_maybe_bash_wrap` must return the bare argv on win32 even when
+    `enabled=True` — this is what makes `bash_wrap_spawn`'s default-True
+    harmless there instead of routing every assignment through a `bash`
+    that isn't guaranteed present (and, where it is — Git for Windows'
+    MSYS bash — doesn't preserve the same-PID invariant the wrap exists
+    for). Runs on every platform (monkeypatches `coord.agent.sys.platform`
+    rather than requiring an actual win32 host), so this regression-guards
+    the fix on the Linux/macOS CI that actually exercises it.
+    """
+    import coord.agent as agent_mod
+    from coord.agent import _maybe_bash_wrap
+
+    argv = ["claude", "-p"]
+    monkeypatch.setattr(agent_mod.sys, "platform", "win32")
+    assert _maybe_bash_wrap(argv, enabled=True) == argv
+    assert _maybe_bash_wrap(argv, enabled=False) == argv
+
+
+@_bash_wrap_posix_only
 def test_spawn_bash_wrap_enabled_routes_through_bash(tmp_path: Path) -> None:
     """With bash_wrap_spawn=True, _spawn launches via bash -c 'exec ...'."""
     import coord.agent as agent_mod
@@ -4367,7 +4411,33 @@ def test_stash_artifacts_for_branch_partial_miss_logs_named_glob(
 
 # ── #1323: build_command runs before stash (fix #3) ──────────────────────────
 
+# #2843 investigation note (NOT the W11 reap-lifecycle cluster this issue is
+# otherwise about, and NOT #1163 either): `_run_pre_stash_build`
+# (coord/agent.py) unconditionally runs the operator-authored
+# `build_commands` string from coordinator.yml via `["/bin/sh", "-c", ...]`.
+# That's a real win32 gap — there is no `/bin/sh` on Windows — but it is a
+# DIFFERENT, pre-existing limitation from the reap-status-stuck-on-FAILED
+# signature #2843 targets (this fails a log-content assertion about the
+# build command's own output, never the assignment's status), and the two
+# tests below each hand it a POSIX-only shell snippet (`printf
+# "\\x7fELF%0200d" ...`, `exit 42`) as their `build_commands` value, so even
+# swapping the interpreter for `cmd /c` would not make them portable — the
+# fixture content itself is shell-specific, not just the dispatch mechanism.
+# Porting `build_commands` cross-platform (cmd.exe/PowerShell translation of
+# an arbitrary operator-authored shell string) is real, separate scope this
+# slice does not take on; skip rather than half-port.
+_build_command_posix_only = pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="build_commands (coordinator.yml) runs via `/bin/sh -c` "
+    "(coord.agent._run_pre_stash_build) and these two tests' own "
+    "build_commands values are POSIX shell snippets — no `/bin/sh` on "
+    "Windows, and no portable stand-in without a cross-platform "
+    "build_commands port (separate from #2843's W11 reap-lifecycle cluster "
+    "and from #1163's Job Objects/ConPTY/junctions scope)",
+)
+
 
+@_build_command_posix_only
 def test_stash_artifacts_build_command_runs_before_glob(tmp_path: Path) -> None:
     """build_command is run in the worktree before the artifact glob (#1323 fix #3).
 
@@ -4432,6 +4502,7 @@ def test_stash_artifacts_build_command_runs_before_glob(tmp_path: Path) -> None:
     assert "pre-stash build" in log_text
 
 
+@_build_command_posix_only
 def test_stash_artifacts_build_command_logged_on_failure(tmp_path: Path) -> None:
     """A failing build_command is logged but does not abort the stash (#1323 fix #3).
 

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/tests/test_agent_api_error.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import json
 import subprocess
+import sys
 from pathlib import Path
 
 import pytest
@@ -47,10 +48,6 @@ def repo_local_only(tmp_path: Path) -> Path:
     return repo
 
 
-def _shell_quote(s: str) -> str:
-    return "'" + s.replace("'", "'\\''") + "'"
-
-
 # The #1563 evidence, verbatim shape.
 _ERROR_RESULT_EVENT = {
     "type": "result",
@@ -81,11 +78,18 @@ _OK_RESULT_EVENT = {
 }
 
 
-def _printf_lines(*events: dict) -> str:
-    """Shell snippet that prints each event as one NDJSON line."""
-    return "; ".join(
-        f"printf '%s\\n' {_shell_quote(json.dumps(e))}" for e in events
-    )
+# Portable replacement for the POSIX-only `["/bin/sh", "-c", "printf ..."]`
+# fake worker shape (#2725/#2843): `_print_lines_argv` runs the equivalent via
+# `sys.executable -c` instead of a shell — no `/bin/sh` dependency, which is
+# absent on Windows and was failing every test in this file at spawn time
+# regardless of the `_maybe_bash_wrap` default (#2843's OTHER root cause,
+# independent of the bash-wrap-default fix in `coord/agent.py`).
+def _print_lines_argv(*events: dict, exit_code: int = 0) -> list[str]:
+    """One NDJSON line per *event*, printed via a real python child process."""
+    script = "".join(f"print({json.dumps(e)!r})\n" for e in events)
+    if exit_code:
+        script += f"import sys; sys.exit({exit_code})\n"
+    return [sys.executable, "-c", script]
 
 
 def test_terminal_api_error_recorded_failed(
@@ -100,10 +104,7 @@ def test_terminal_api_error_recorded_failed(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -134,10 +135,7 @@ def test_terminal_api_error_appears_in_log(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -168,10 +166,7 @@ def test_normal_successful_result_still_done(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _OK_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _OK_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -203,10 +198,7 @@ def test_transient_error_then_internal_retry_success_still_done(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT, _OK_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT, _OK_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -239,10 +231,7 @@ def test_terminal_api_error_with_nonzero_exit(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            f"{_printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT)}; exit 1",
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT, exit_code=1),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -275,10 +264,7 @@ def test_terminal_api_error_still_captures_claude_session_id(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -325,10 +311,7 @@ def test_reap_parses_the_terminal_log_only_once(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            _printf_lines(_INIT_EVENT, _ERROR_RESULT_EVENT),
-        ],
+        worker_command=lambda spec: _print_lines_argv(_INIT_EVENT, _ERROR_RESULT_EVENT),
     )
     spec = AssignmentSpec(
         repo_name="api",

{code_coordinator-0.5.578 → code_coordinator-0.5.580}/tests/test_agent_update_bluegreen.py

@@ -24,6 +24,7 @@ from coord.agent_update import (
     perform_update,
     rollback,
 )
+from coord.dirlink import is_dir_link
 from coord.platform_paths import venv_bin, venv_exe, venv_pip, venv_python
 
 #: #2684 (W4): `current_slot()`/`ensure_symlink_layout()` call `Path.resolve()`
@@ -159,7 +160,7 @@ class TestSymlinkLayout:
         active = ensure_symlink_layout(venv_dir)
 
         assert active == tmp_path / ".coord-venv.blue"
-        assert venv_dir.is_symlink()
+        assert is_dir_link(venv_dir)
         assert _same_path(current_slot(venv_dir), active)
         assert (venv_dir / "marker").read_text() == "original install\n"