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

{code_coordinator-0.5.59 → code_coordinator-0.5.61}/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.61}/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.61",
+  "distance": 0,
+  "node": "g74884c7dae4507e48a87e147dbfae31765822fd5",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-14"
+}

{code_coordinator-0.5.59 → code_coordinator-0.5.61}/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.61}/coord/commands/release.py

@@ -1877,9 +1877,82 @@ def _drain(
         sleep_fn(max(0.0, min(poll_interval, deadline - elapsed)))
 
 
+def _parse_trailing_json(stdout: str) -> dict | None:
+    """The last top-level JSON object printed to *stdout*, or ``None``.
+
+    #2187: this used to look only at the LAST LINE of stdout and try to
+    parse THAT LINE alone as JSON. `coord release propagate --json` (like
+    every ``--json`` command in this codebase) prints its record via
+    ``json.dumps(..., indent=2, ...)`` — pretty-printed, for a human running
+    it by hand — which means the payload spans many lines and its own last
+    line is just ``}``, never a complete object on its own. The old check
+    therefore never found the record for ANY propagate run, successful or
+    not, and every call fell back to the ``f"exit {code}"`` placeholder in
+    `_run_propagate` below — which is exactly the false "propagate-failed
+    (status=exit 0, exit=0)" #2187 reports for a verified, exit-0 roll.
+
+    This instead finds the LAST line that is the object's own unindented
+    ``{`` (json.dumps never indents the outermost brace) and parses
+    everything from there to the end of stdout as one document. A single
+    compact line (no ``indent=``) still works too, tried second.
+    """
+    import json as _json  # noqa: PLC0415
+
+    text = stdout.strip()
+    if not text:
+        return None
+    lines = text.splitlines()
+    for idx in range(len(lines) - 1, -1, -1):
+        if lines[idx].strip() != "{":
+            continue
+        try:
+            payload = _json.loads("\n".join(lines[idx:]))
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    for line in reversed(lines):
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            payload = _json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            return payload
+    return None
+
+
+def _latest_propagate_record_since(state_dir: Path, since: float) -> dict | None:
+    """The propagation journal's own record for the run started at/after
+    *since*, if any — the ground truth `coord release history` itself reads.
+
+    #2187 proposal 1: "read `coord release history` for the run it just
+    launched rather than inferring from a side-channel [stdout]." The
+    journal has no request id to join on, so this uses ``started_at``: the
+    subprocess `_run_propagate` shells out to is synchronous, so by the
+    time it has returned, a successful run has already appended its record
+    with a ``started_at`` at or after the moment this function's caller
+    launched it. Picks the OLDEST such record — the first thing written
+    after launch — in case some unrelated `coord release propagate` run
+    elsewhere raced it onto the same shared journal.
+    """
+    from coord import release_propagate as rp  # noqa: PLC0415
+
+    candidates = [
+        rec for rec in rp.read_records(state_dir)
+        if isinstance(rec.get("started_at"), (int, float)) and rec["started_at"] >= since
+    ]
+    if not candidates:
+        return None
+    return min(candidates, key=lambda rec: rec["started_at"])
+
+
 def _run_propagate(
-    *, daemon_host: str, target_version: str, config_path: Path, runner=None,
-) -> tuple[str, int, str]:
+    *, daemon_host: str, target_version: str, config_path: Path, state_dir: Path,
+    runner=None, now_fn=None,
+) -> tuple[str, int, str, float | None]:
     """``coord release propagate --daemon-host ... --target ... --json``.
 
     A real subprocess of THIS interpreter (matches `_roll_tui`/
@@ -1890,15 +1963,26 @@ def _run_propagate(
     run decided was needed is the version that actually rolls, even if a new
     release lands on PyPI mid-drain.
 
-    Returns ``(status, exit_code, combined_output)``. ``status`` is parsed
-    from the last JSON line of stdout (propagate's own record); parsing
-    failures fall back to ``f"exit {code}"`` rather than raising — a window
-    run must never crash because propagate's output was unexpected.
+    Returns ``(status, exit_code, combined_output, propagate_started_at)``.
+    ``status`` is read from the propagation journal entry that run itself
+    wrote (:func:`_latest_propagate_record_since`) — the same ground truth
+    `coord release history` reads — not reparsed from stdout (#2187:
+    reparsing stdout was the false-negative bug). ``propagate_started_at``
+    is that record's own ``started_at``, stamped onto the window's own
+    record so `window-history` can be joined to `history` (#2187 proposal
+    2) instead of the two stores re-deciding the same outcome separately.
+    Only when no journal entry can be found — the subprocess died before
+    writing one, or the journal write itself failed — does this fall back
+    to `_parse_trailing_json` on stdout, and then to ``f"exit {code}"``;
+    either fallback returns ``None`` for ``propagate_started_at`` since
+    there is then nothing to join to.
     """
-    import json as _json  # noqa: PLC0415
     import subprocess  # noqa: PLC0415
+    import time  # noqa: PLC0415
 
     run = runner or subprocess.run
+    clock = now_fn or time.time
+    launched_at = clock()
     argv = [
         sys.executable, "-m", "coord.cli", "release", "propagate",
         "--daemon-host", daemon_host, "--target", target_version,
@@ -1908,23 +1992,22 @@ def _run_propagate(
         proc = run(argv, capture_output=True, text=True, timeout=1800)
     except Exception as exc:  # noqa: BLE001
         detail = f"{type(exc).__name__}: {exc}"
-        return f"error: {detail}", 1, detail
+        return f"error: {detail}", 1, detail, None
     code = getattr(proc, "returncode", 1)
     stdout = getattr(proc, "stdout", "") or ""
     stderr = getattr(proc, "stderr", "") or ""
-    status = f"exit {code}"
-    for line in reversed(stdout.strip().splitlines()):
-        line = line.strip()
-        if not line.startswith("{"):
-            continue
-        try:
-            payload = _json.loads(line)
-        except ValueError:
-            continue
-        if isinstance(payload, dict) and payload.get("status"):
-            status = str(payload["status"])
-        break
-    return status, code, (stdout + ("\n" + stderr if stderr else "")).strip()
+    output = (stdout + ("\n" + stderr if stderr else "")).strip()
+
+    record = _latest_propagate_record_since(state_dir, launched_at)
+    if record is not None:
+        status = str(record.get("status") or f"exit {code}")
+        return status, code, output, record.get("started_at")
+
+    payload = _parse_trailing_json(stdout)
+    status = (
+        str(payload["status"]) if payload and payload.get("status") else f"exit {code}"
+    )
+    return status, code, output, None
 
 
 #: Where a skipped/failed nightly window (trap 3) is recorded — same
@@ -2161,13 +2244,14 @@ def release_nightly_window(  # noqa: PLR0912, PLR0915 — a pipeline; see module
                 status = rw.STATUS_DRAIN_TIMEOUT
             else:
                 # ── 5. roll — the daemon host is now provably free ─────────
-                prop_status, prop_exit, prop_output = _run_propagate(
+                prop_status, prop_exit, prop_output, prop_started_at = _run_propagate(
                     daemon_host=daemon_name, target_version=record.target_version,
-                    config_path=config_path,
+                    config_path=config_path, state_dir=state_dir,
                 )
                 record.propagate_status = prop_status
                 record.propagate_exit_code = prop_exit
                 record.propagate_output = prop_output
+                record.propagate_started_at = prop_started_at
                 if prop_output:
                     click.echo(prop_output)
 
@@ -2193,11 +2277,38 @@ def release_nightly_window(  # noqa: PLR0912, PLR0915 — a pipeline; see module
                     click.echo(f"error: {record.error}", err=True)
                     _escalate_window(record, reason=record.error)
                     status = rw.STATUS_PROPAGATE_DEFERRED
+                elif prop_status.startswith("exit ") or prop_status.startswith("error:"):
+                    # #2187 proposal 3: this arm is reached only when NEITHER
+                    # ground truth was available — no matching entry in
+                    # `coord release history` (see
+                    # `_latest_propagate_record_since`) AND no parseable
+                    # `--json` payload on stdout (`_parse_trailing_json`).
+                    # `prop_status` here is one of those two functions'
+                    # placeholder fallbacks, never a real outcome — so the
+                    # message must say exactly what evidence is missing
+                    # instead of quoting the placeholder as if it were one
+                    # (the old text, "status=exit 0, exit=0", read as a
+                    # verification failure when exit 0 is what a VERIFIED
+                    # roll also produces).
+                    record.error = (
+                        f"coord release propagate exited {prop_exit}, but its "
+                        "outcome could not be confirmed: no matching entry "
+                        "was found in `coord release history` for this run, "
+                        "and its --json stdout had no parseable status "
+                        "either — see propagate_output"
+                    )
+                    click.echo(f"error: {record.error}", err=True)
+                    _escalate_window(record, reason=record.error)
+                    status = rw.STATUS_PROPAGATE_FAILED
+                    exit_code = prop_exit or 1
                 else:
+                    # A real, ground-truth status from `coord release
+                    # history` — just not a verified roll (e.g. `failed` or
+                    # `rolled-back`).
                     record.error = (
-                        f"coord release propagate did not verify a roll "
-                        f"(status={prop_status}, exit={prop_exit}) despite a "
-                        f"drained daemon host"
+                        f"coord release propagate did not verify a roll — "
+                        f"`coord release history` recorded status="
+                        f"{prop_status!r} (exit {prop_exit}) for this run"
                     )
                     click.echo(f"error: {record.error}", err=True)
                     _escalate_window(record, reason=record.error)

{code_coordinator-0.5.59 → code_coordinator-0.5.61}/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.61}/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.61}/coord/release_window.py

@@ -190,6 +190,14 @@ class WindowRecord:
     propagate_status: str | None = None
     propagate_exit_code: int | None = None
     propagate_output: str = ""
+    #: The propagation journal record's OWN ``started_at`` — the join key
+    #: (#2187 proposal 2) that lets `window-history` be correlated to
+    #: `coord release history` for the SAME run, instead of each store
+    #: independently re-deciding what happened. ``None`` when no matching
+    #: journal record could be found (see
+    #: `coord.commands.release._latest_propagate_record_since`) — there is
+    #: then nothing to join to.
+    propagate_started_at: float | None = None
     finished_at: float | None = None
     error: str | None = None
     dry_run: bool = False
@@ -327,9 +335,14 @@ def render_record(record: WindowRecord | Mapping[str, Any]) -> list[str]:
         if data.get("drain_detail"):
             lines.append(f"      {data['drain_detail']}")
     if data.get("propagate_status"):
+        joined = (
+            f" [history @ {_stamp(data['propagate_started_at'])}]"
+            if data.get("propagate_started_at")
+            else ""
+        )
         lines.append(
             f"    propagate: {data['propagate_status']} "
-            f"(exit {data.get('propagate_exit_code')})"
+            f"(exit {data.get('propagate_exit_code')}){joined}"
         )
     if data.get("queue_restarted") is not None:
         lines.append(