code-coordinator 0.5.59__tar.gz → 0.5.60__tar.gz

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/CLAUDE.md

@@ -100,6 +100,16 @@ coord approve --dry-run 1,2
 coord assign --dry-run precision claude-coordinator 42
 ```
 
+**Workers: scope your test run to your diff, never `pytest` bare (#2169).**
+The full suite exceeds Claude Code's 600s Bash ceiling on this repo and
+duplicates the Test stage + CI, which both run it against your pushed SHA
+regardless. Run just the file(s) that mirror what you changed — `pytest
+tests/test_<module>.py` for a `coord/<module>.py` change, `cargo test` from
+`tui/` scoped with a test-name filter for a `tui/**` change. To see what
+the Test stage itself would run for your diff (and confirm you're not
+missing a suite), `scripts/coord-test-runner.sh <worktree> --print-routing`
+computes the routing without actually building or testing anything.
+
 ## Key Design Decisions
 
 - **No API key needed.** Everything uses `claude -p` which runs on Max/Pro subscription via OAuth.

{code_coordinator-0.5.59/code_coordinator.egg-info → code_coordinator-0.5.60}/PKG-INFO

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

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

@@ -720,6 +720,7 @@ tests/test_watch.py
 tests/test_worker_events.py
 tests/test_worker_image_pin_sync.py
 tests/test_worker_safety.py
+tests/test_worker_test_scoping.py
 tests/test_worktree.py
 tests/test_worktree_rmtree_chokepoint.py
 tests/acceptance/ms-33/audit_1039.rs

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/code_coordinator.egg-info/scm_file_list.json

@@ -750,6 +750,7 @@
     "tests/test_worker_events.py",
     "tests/test_worker_image_pin_sync.py",
     "tests/test_worker_safety.py",
+    "tests/test_worker_test_scoping.py",
     "tests/test_worktree.py",
     "tests/test_worktree_rmtree_chokepoint.py",
     "tui/Cargo.lock",

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.59",
+  "tag": "0.5.60",
   "distance": 0,
-  "node": "g3cb11f81fa08e124d66859415a0b01368d4da64a",
+  "node": "ge01001eaf8201fb10e8bd9b1a0f6c018d93b3fb8",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/coord/agent.py

@@ -2845,9 +2845,17 @@ This session is ONE-SHOT and non-interactive (#1394):
 completion notifications will NEVER reach you — nothing wakes you up.
 - NEVER start a long-running command in the background and then end your \
 turn waiting for it (no `run_in_background`, no `&`, no "I'll wait for the \
-test run to finish"). Run it in the FOREGROUND and block until it returns, \
-or raise the timeout, or skip it and say so. If you end your turn waiting, \
-the session is over and your work is thrown away.
+test run to finish") — there is no next turn for a notification to land \
+in, so ending your turn that way throws the work away. Prefer running it \
+in the FOREGROUND and blocking until it returns. If it genuinely cannot \
+finish inside one Bash call, you may background it and poll it yourself, \
+in bounded steps, from THIS SAME still-running session — `Monitor`, or \
+repeated `TaskOutput` calls with a bounded `timeout`, never a foreground \
+loop that blocks past the ceiling (`until ! pgrep ...; do sleep ...; done` \
+hits the identical 600s wall) and never a final message that leaves it \
+running unattended and relies on being woken back up. Otherwise, raise the \
+timeout or skip it and say so. If you end your turn waiting, the session \
+is over and your work is thrown away.
 - ALWAYS `git add`, `git commit`, and `git push origin HEAD` BEFORE your \
 final message — even if the build is broken, the tests are failing, or you \
 ran out of time. Uncommitted changes are destroyed when the session ends. \
@@ -2883,8 +2891,25 @@ intentional `#[allow]` with reason, a deferred refactor flagged \
 elsewhere), explicitly call it out in your final message with the \
 reason. Don't silently ship warnings.
 - Re-run the build after fixes to confirm clean output.
-- Run the project's test command (`cargo test`, `pytest`, etc.) and \
-confirm it passes before declaring done.
+- Run only the tests that cover your diff — never the project's whole \
+test suite. A full suite routinely exceeds this tool's 600-second Bash \
+ceiling, and a worker that tries to shepherd it past that wall (splitting \
+it into chunks, backgrounding it and blocking on a poll loop, ...) burns \
+most of a session on that instead of the fix, for no net-new signal: the \
+Test stage and CI both re-run the FULL suite against your pushed SHA right \
+after you, on a clean checkout, which is strictly better evidence than a \
+worker's own partial run (#2169). Find the test file(s)/module(s) whose \
+name or path mirrors what you changed (e.g. `tests/test_<module>.py` for \
+`coord/<module>.py`, the crate-local `#[cfg(test)]` block for a Rust file) \
+and run just those — confirm they pass before declaring done.
+- Exception: if this assignment IS an oracle-loop acceptance round (you \
+were told to run `coord acceptance run --issue N`), keep running that \
+sealed slice as many times as it takes to go green. It is the loop's \
+convergence signal, not duplicated effort, and the scoping rule above does \
+not apply to it.
+- If even the scoped run genuinely cannot finish in time, follow the \
+background-and-poll pattern in the ONE-SHOT section above — do not invent \
+a chunk-and-loop workaround.
 
 #252: before exiting, emit a SMOKE_TESTS block telling the human what to \
 manually verify.  You changed the code; you know what's worth poking.
@@ -3668,7 +3693,13 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
     else:
         system_prompt = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
         system_prompt += build_deny_prompt(spec.deny_commands)
-        allowed_tools = "Read,Edit,Write,Bash"
+        # #2169: `Monitor` is the sanctioned way to poll a backgrounded
+        # long-running command in bounded steps (see the ONE-SHOT section of
+        # WORKER_SYSTEM_PROMPT) instead of a foreground loop that blocks
+        # past the 600s Bash ceiling. `TaskOutput`/`TaskStop` were already
+        # reachable without being in this list; `Monitor` was the one
+        # observed denied.
+        allowed_tools = "Read,Edit,Write,Bash,Monitor"
 
     # NOTE: briefing is NOT passed as a positional arg — it is written to
     # stdin as the first stream-json user message by ``_spawn``.

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/coord/providers/claude.py

@@ -173,7 +173,10 @@ class ClaudeProvider(Provider):
             else:
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
-                _at = "Read,Edit,Write,Bash"
+                # #2169: keep in sync with default_worker_command's identical
+                # branch — Monitor is the sanctioned bounded-poll tool for a
+                # backgrounded long-running command.
+                _at = "Read,Edit,Write,Bash,Monitor"
 
             if system_prompt is None:
                 system_prompt = _sp

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/coord/providers/claude_pty.py

@@ -488,7 +488,11 @@ class ClaudePtyProvider(Provider):
             else:
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
-                _at = "Read,Edit,Write,Bash"
+                # #2169: keep in sync with default_worker_command's and
+                # ClaudeProvider.build_command's identical branch — Monitor
+                # is the sanctioned bounded-poll tool for a backgrounded
+                # long-running command.
+                _at = "Read,Edit,Write,Bash,Monitor"
 
             if system_prompt is None:
                 system_prompt = _sp

{code_coordinator-0.5.59 → code_coordinator-0.5.60}/tests/test_providers_pty.py

@@ -199,6 +199,28 @@ def test_pty_build_command_branches_match_claude_for_plan_type() -> None:
     assert argv[argv.index("--allowedTools") + 1] == legacy_at
 
 
+@pytest.mark.parametrize("spec_type", ["work", "review", "smoke", "conflict-fix", "fix"])
+def test_pty_build_command_branches_match_claude_for_work_type(spec_type: str) -> None:
+    """#2169: the generic-worker (``else``) branch must stay in parity too.
+
+    ``default_worker_command`` and ``ClaudeProvider.build_command`` both
+    grant ``Monitor`` alongside ``Read,Edit,Write,Bash`` for write-capable
+    spec types so a worker can bound-poll a backgrounded long-running
+    command. ``ClaudePtyProvider.build_command`` shares the same
+    system-prompt/allowed-tools logic and must not drift from it — this
+    regression-guards the drift where only two of the three call sites
+    were updated to add ``Monitor``.
+    """
+    spec = _make_spec(type=spec_type)
+    argv = ClaudePtyProvider().build_command(spec)
+    legacy = default_worker_command(spec)
+    legacy_sp = legacy[legacy.index("--system-prompt") + 1]
+    legacy_at = legacy[legacy.index("--allowedTools") + 1]
+    assert argv[argv.index("--system-prompt") + 1] == legacy_sp
+    assert argv[argv.index("--allowedTools") + 1] == legacy_at
+    assert "Monitor" in argv[argv.index("--allowedTools") + 1]
+
+
 # ── ClaudePtyProvider: capabilities ──────────────────────────────────────────
 
 

code_coordinator-0.5.60/tests/test_worker_test_scoping.py

@@ -0,0 +1,162 @@
+"""Regression tests for #2169 — workers were told to run the project's
+*whole* test command before declaring done. On this repo (and others with a
+slow suite) that routinely exceeds Claude Code's 600-second hard Bash
+ceiling: the call is killed with no output, and workers improvised
+increasingly baroque workarounds (chunking the suite, backgrounding it and
+blocking on a poll loop that hits the identical 600s wall) that burned the
+majority of a work leg's wall clock for zero signal the Test stage and CI
+don't already produce independently.
+
+Covers:
+* the "run the project's test command" phrasing must NOT reappear verbatim
+  (the exact bug being fixed) — a regression guard;
+* the prompt instead tells the worker to scope its run to the files/suites
+  covering its diff;
+* the oracle loop's acceptance carve-out survives — `coord acceptance run
+  --issue N` must still be run repeatedly, not scoped down or skipped, or
+  the oracle loop's whole convergence design (docs/ORACLE_LOOP.md) breaks;
+* the sanctioned bounded-poll pattern (`Monitor` / `TaskOutput`) is named in
+  the prompt, and `Monitor` is actually reachable — added to the worker's
+  `--allowedTools` so the pattern isn't dead advice (#2158's fix leg had it
+  denied and fell back to a blocking `until` loop that hit the same wall).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from coord.agent import (
+    WORKER_SYSTEM_PROMPT,
+    AssignmentSpec,
+    default_worker_command,
+)
+from coord.providers.claude import ClaudeProvider
+
+
+def _work_spec(**overrides) -> AssignmentSpec:
+    base = dict(
+        repo_name="api", repo_path="/tmp/api", issue_number=2169,
+        issue_title="scope worker tests", briefing="b", branch="main",
+        type="work",
+    )
+    base.update(overrides)
+    return AssignmentSpec(**base)
+
+
+# ── regression guard: the exact bug must not reappear ────────────────────────
+
+
+def test_worker_system_prompt_does_not_tell_workers_to_run_whole_suite() -> None:
+    """The load-bearing bug: this literal instruction sent workers spelunking
+    through 600s timeouts trying to run a full suite that was never their
+    job — the Test stage and CI both re-run it against the pushed SHA."""
+    assert (
+        "Run the project's test command" not in WORKER_SYSTEM_PROMPT
+    ), "the pre-#2169 whole-suite instruction has reappeared in WORKER_SYSTEM_PROMPT"
+
+
+# ── the worker is told to scope its run to the diff ──────────────────────────
+
+
+def test_worker_system_prompt_instructs_scoping_to_the_diff() -> None:
+    p = WORKER_SYSTEM_PROMPT
+    assert "Before declaring done" in p
+    flat = " ".join(p.split())
+    assert "Run only the tests that cover your diff" in flat
+    assert "never the project's whole test suite" in flat
+    # Names the actual mechanism: the Test stage + CI already do the full run.
+    assert "Test stage and CI both re-run the FULL suite" in flat
+    assert "#2169" in flat
+
+
+def test_worker_system_prompt_names_the_600s_ceiling() -> None:
+    """Explaining *why* (not just *what*) is what stops a worker from
+    reinventing the same workaround under a different name."""
+    assert "600-second" in WORKER_SYSTEM_PROMPT or "600s" in WORKER_SYSTEM_PROMPT
+
+
+def test_worker_system_prompt_forbids_the_observed_workarounds() -> None:
+    """#2158: the worker split `ls tests/*.py` into thirds and separately
+    tried backgrounding + a blocking `until ! pgrep` poll. Both must be
+    named as the anti-pattern, not left for the next worker to reinvent."""
+    flat = " ".join(WORKER_SYSTEM_PROMPT.split())
+    assert "chunk-and-loop workaround" in flat or "splitting it into chunks" in flat
+
+
+# ── oracle loop carve-out must survive ────────────────────────────────────────
+
+
+def test_worker_system_prompt_carves_out_oracle_acceptance_runs() -> None:
+    """docs/ORACLE_LOOP.md: the sealed acceptance slice run repeatedly, warm,
+    in-session IS the convergence design — a scoping instruction that
+    silently swept this up would disable the oracle loop's inner loop."""
+    flat = " ".join(WORKER_SYSTEM_PROMPT.split())
+    assert "coord acceptance run --issue N" in flat
+    assert "oracle-loop acceptance round" in flat
+    assert "keep running" in flat
+    assert "does not apply to it" in flat
+
+
+# ── the bounded-poll pattern is named, and Monitor is actually usable ────────
+
+
+def test_worker_system_prompt_names_bounded_poll_pattern_not_blocking_loop() -> None:
+    p = WORKER_SYSTEM_PROMPT
+    flat = " ".join(p.split())
+    assert "Monitor" in flat
+    assert "TaskOutput" in flat
+    # The exact failure mode from #2158's fix leg — must be named as wrong.
+    assert "until ! pgrep" in flat or "blocks past the ceiling" in flat
+    # #1394 invariant must still hold: never end the turn to wait passively.
+    assert "ONE-SHOT" in p
+    assert "run_in_background" in p
+    assert "no next turn" in p.lower()
+
+
+def test_default_worker_command_grants_monitor_for_work_type() -> None:
+    """Advice to use Monitor is dead advice if the tool is denied — #2158's
+    fix leg reached for it via ToolSearch and got `permission_denied`."""
+    argv = default_worker_command(_work_spec())
+    allowed = argv[argv.index("--allowedTools") + 1]
+    assert "Monitor" in allowed.split(",")
+    # Existing capabilities must not have been dropped in the process.
+    for tool in ("Read", "Edit", "Write", "Bash"):
+        assert tool in allowed.split(",")
+
+
+@pytest.mark.parametrize("spec_type", ["review", "fix", "smoke", "conflict-fix"])
+def test_default_worker_command_other_write_types_also_get_monitor(spec_type: str) -> None:
+    """`review`/`fix`/`smoke`/`conflict-fix` all fall through the same `else`
+    branch as `work` — confirm the grant isn't accidentally work-only."""
+    argv = default_worker_command(_work_spec(type=spec_type))
+    allowed = argv[argv.index("--allowedTools") + 1]
+    assert "Monitor" in allowed.split(",")
+
+
+def test_mock_author_type_does_not_gain_monitor() -> None:
+    """Scope check: the Monitor grant is deliberately added to the generic
+    worker branch only, not copy-pasted onto every Edit-capable type."""
+    argv = default_worker_command(_work_spec(type="mock-author"))
+    allowed = argv[argv.index("--allowedTools") + 1]
+    assert allowed == "Read,Edit,Write,Bash"
+
+
+def test_plan_type_unaffected_by_monitor_grant() -> None:
+    argv = default_worker_command(_work_spec(type="plan"))
+    allowed = argv[argv.index("--allowedTools") + 1]
+    assert allowed == "Read,Bash"
+
+
+# ── ClaudeProvider parity (coord/providers/claude.py is a documented direct
+#    transcription of default_worker_command; #2169's Monitor grant must be
+#    mirrored there or the two providers silently diverge) ──────────────────
+
+
+def test_claude_provider_parity_includes_monitor_grant() -> None:
+    spec = _work_spec()
+    legacy = default_worker_command(spec)
+    provider_result = ClaudeProvider().build_command(spec)
+    legacy_allowed = legacy[legacy.index("--allowedTools") + 1]
+    provider_allowed = provider_result[provider_result.index("--allowedTools") + 1]
+    assert provider_allowed == legacy_allowed
+    assert "Monitor" in provider_allowed.split(",")