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

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

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

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

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

{code_coordinator-0.5.578 → code_coordinator-0.5.579}/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.579}/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.579}/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.579}/tests/test_agent_usage_limit.py

@@ -14,6 +14,7 @@ detection wired in `AgentServer._reap` (coord/agent.py).
 from __future__ import annotations
 
 import subprocess
+import sys
 from pathlib import Path
 
 import pytest
@@ -49,6 +50,30 @@ def repo_local_only(tmp_path: Path) -> Path:
 _KILL_MESSAGE = "You’ve hit your session limit · resets 8:30pm (America/Chicago)"
 
 
+# Portable replacements for the POSIX-only `["/bin/sh", "-c", script]` fake
+# worker shape (#2725/#2843): `script` below is inline PYTHON, run via
+# `sys.executable -c`, never 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 _kill_message_argv(*, exit_code: int = 0) -> list[str]:
+    """`printf '%s\\n' <msg>[; exit N]`, as a portable argv."""
+    script = f"print({_KILL_MESSAGE!r})\n"
+    if exit_code:
+        script += f"import sys; sys.exit({exit_code})\n"
+    return [sys.executable, "-c", script]
+
+
+_PARTIAL_COMMIT_THEN_KILL_SCRIPT = (
+    "import subprocess\n"
+    "open('partial.txt', 'w').write('partial\\n')\n"
+    "subprocess.run(['git', 'add', 'partial.txt'], check=True)\n"
+    "subprocess.run(['git', '-c', 'user.email=t@t.com', '-c', 'user.name=T', "
+    "'commit', '-q', '-m', 'partial'], check=True)\n"
+    f"print({_KILL_MESSAGE!r})\n"
+)
+
+
 def test_usage_limit_kill_detected_on_nonzero_exit(
     tmp_path: Path, repo_local_only: Path
 ) -> None:
@@ -59,10 +84,7 @@ def test_usage_limit_kill_detected_on_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 '%s\\n' {_shell_quote(_KILL_MESSAGE)}; exit 1",
-        ],
+        worker_command=lambda spec: _kill_message_argv(exit_code=1),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -101,10 +123,7 @@ def test_usage_limit_kill_detected_on_clean_exit_zero_commits(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            f"printf '%s\\n' {_shell_quote(_KILL_MESSAGE)}",
-        ],
+        worker_command=lambda spec: _kill_message_argv(),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -149,10 +168,7 @@ def test_usage_limit_kill_never_recorded_done_even_with_commits(
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
         worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            "printf 'partial\\n' > partial.txt && git add partial.txt && "
-            "git -c user.email=t@t.com -c user.name=T commit -q -m 'partial' && "
-            f"printf '%s\\n' {_shell_quote(_KILL_MESSAGE)}",
+            sys.executable, "-c", _PARTIAL_COMMIT_THEN_KILL_SCRIPT,
         ],
     )
     spec = AssignmentSpec(
@@ -199,7 +215,9 @@ def test_zero_commit_clean_exit_is_advisory_for_all_work_like_types(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: ["/bin/sh", "-c", "echo 'already implemented'"],
+        worker_command=lambda spec: [
+            sys.executable, "-c", "print('already implemented')",
+        ],
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -232,7 +250,7 @@ def test_review_type_zero_commits_still_done(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: ["/bin/sh", "-c", "echo 'LGTM'"],
+        worker_command=lambda spec: [sys.executable, "-c", "print('LGTM')"],
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -262,7 +280,10 @@ def test_normal_failure_has_no_usage_limit_reason(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: ["/bin/sh", "-c", "echo boom >&2; exit 1"],
+        worker_command=lambda spec: [
+            sys.executable, "-c",
+            "import sys; print('boom', file=sys.stderr); sys.exit(1)",
+        ],
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -290,10 +311,7 @@ def test_usage_limit_reason_appears_in_log(
         repos=["api"],
         repo_paths={"api": str(repo_local_only)},
         state_dir=tmp_path / "state",
-        worker_command=lambda spec: [
-            "/bin/sh", "-c",
-            f"printf '%s\\n' {_shell_quote(_KILL_MESSAGE)}; exit 1",
-        ],
+        worker_command=lambda spec: _kill_message_argv(exit_code=1),
     )
     spec = AssignmentSpec(
         repo_name="api",
@@ -310,7 +328,3 @@ def test_usage_limit_reason_appears_in_log(
     log_text = Path(final.log_path).read_text()
     assert "usage-limit kill detected" in log_text
     server.shutdown()
-
-
-def _shell_quote(s: str) -> str:
-    return "'" + s.replace("'", "'\\''") + "'"