code-coordinator 0.5.247__tar.gz → 0.5.248__tar.gz

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.247",
+  "tag": "0.5.248",
   "distance": 0,
-  "node": "g4f09a4eb9bb9c5df7bd584afa61ad7985896abe7",
+  "node": "g698bc8431c005f357304c6d6731da95766129363",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-27"

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/coord/agent.py

@@ -4918,7 +4918,11 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         # (coord.providers.claude_pty.ClaudePtyProvider) intentionally keeps
         # the default sources so an operator's own `coord init`-configured
         # convenience allow-list still applies to a session they're
-        # attached to and watching.
+        # attached to and watching. #2821: that tradeoff also means the PTY
+        # path pays for CLAUDE.md via ambient auto-discovery (~7.7k tok)
+        # instead of the explicit `_claude_md_system_prompt_suffix` embed
+        # below (~5.2k tok) — a deliberately accepted, documented cost; see
+        # the argv comment in ClaudePtyProvider.build_command.
         #
         # #2462 tried `--bare` here (closes settings + hooks + .mcp.json +
         # CLAUDE.md auto-discovery at once, vs. this flag's settings.json-only

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/coord/github_ops.py

@@ -2313,17 +2313,123 @@ def rerun_workflow_run_failed(repo: str, run_id: str) -> bool:
     return True
 
 
+def diff_file_paths(diff_text: str) -> list[str]:
+    """Return every file path touched by *diff_text*, deduped, order-preserving.
+
+    Scans unified-diff file-header lines (``diff --git a/X b/Y``, ``---
+    a/X``, ``+++ b/X``) — cheap, dependency-free (#944 sealing v1) ahead of a
+    real diff parser. Lives here (rather than :mod:`coord.review`, its
+    original home) because :func:`truncate_diff_text` needs it too (#2819)
+    and ``coord.review`` imports :mod:`coord.github_ops`, not the reverse —
+    :mod:`coord.review` re-uses this copy for its own sealed-path /
+    missing-test-coverage checks instead of keeping a second one.
+    """
+    paths: list[str] = []
+    seen: set[str] = set()
+    for line in diff_text.splitlines():
+        candidates: list[str] = []
+        if line.startswith("diff --git "):
+            for part in line.split()[1:]:
+                if part.startswith("a/") or part.startswith("b/"):
+                    candidates.append(part[2:])
+        elif line.startswith("--- a/"):
+            candidates.append(line[len("--- a/"):])
+        elif line.startswith("+++ b/"):
+            candidates.append(line[len("+++ b/"):])
+        for c in candidates:
+            if c not in seen:
+                seen.add(c)
+                paths.append(c)
+    return paths
+
+
+_DIFF_FILE_BOUNDARY_RE = re.compile(r"^diff --git ", re.MULTILINE)
+
+
 def truncate_diff_text(diff: str, max_chars: int = 60000) -> str:
-    """Truncate *diff* to *max_chars* with a trailing note, if it's over.
+    """Truncate *diff* to at most *max_chars*, cutting on a ``diff --git``
+    file boundary rather than mid-hunk, and naming the files that got cut.
 
     Factored out of :func:`pr_diff` (#1475) so callers that need the full,
     untruncated diff for content hashing (``compute_patch_id``) can still
     apply the same display truncation to a *separate* copy shown to a human
     reviewer or embedded in a briefing, without a second ``gh`` fetch.
-    """
-    if len(diff) > max_chars:
-        return diff[:max_chars] + f"\n... [diff truncated at {max_chars} chars] ..."
-    return diff
+
+    #2819: the original version was a blind character slice — handed the
+    reviewer a diff that stopped mid-hunk, with no indication anything was
+    even cut, on any PR whose diff crossed *max_chars* (61% of a review
+    briefing at the flat 60k default). That's a silent coverage hole in a
+    gate that's supposed to be adversarial. This version instead:
+
+    1. Cuts at the last ``diff --git`` boundary that fits within
+       *max_chars* — every file kept in the output is complete, never a
+       partial hunk.
+    2. Appends the paths of every file that got dropped, so the reviewer
+       knows exactly what it did not see and can inspect those files
+       directly (e.g. ``git show``) instead of silently missing them.
+
+    Falls back to the old raw character slice — no boundary preference — when
+    no file boundary fits within *max_chars* at all (a single file's own
+    diff already exceeds the cap, or *diff* isn't a unified diff to begin
+    with). Cutting nothing at that point would just emit an empty string,
+    which is worse than the old behavior. #2819 follow-up: that fallback
+    slice lands *inside* the first file's own diff (the loop below only
+    leaves ``cut_at`` unset when the second file's boundary already exceeds
+    *max_chars*, i.e. before any second file exists in the output) — so
+    that file's header rides into ``head`` looking complete while its body
+    is silently cut mid-hunk. Left unflagged, a reviewer who checks the
+    omitted-files list and finds their file *not* on it would reasonably
+    (and wrongly) conclude it was shown in full. That file is now always
+    called out as truncated, separately from the fully-omitted list.
+    """
+    if len(diff) <= max_chars:
+        return diff
+
+    boundaries = [m.start() for m in _DIFF_FILE_BOUNDARY_RE.finditer(diff)]
+    cut_at: int | None = None
+    for b in boundaries:
+        if b == 0:
+            continue  # the first file's own boundary — cutting here keeps nothing
+        if b > max_chars:
+            break
+        cut_at = b
+
+    if cut_at is None:
+        head = diff[:max_chars]
+        # The cut point falls inside the first file's own diff (see the
+        # docstring above) — flag that file as incomplete rather than
+        # letting it silently pass as "not omitted, so fully shown".
+        all_paths = diff_file_paths(diff)
+        incomplete = all_paths[0] if all_paths else None
+    else:
+        head = diff[:cut_at].rstrip("\n")
+        incomplete = None
+
+    dropped = [p for p in diff_file_paths(diff) if p not in diff_file_paths(head)]
+
+    note = f"\n... [diff truncated at {max_chars} chars"
+    tallies = []
+    if incomplete:
+        tallies.append(f"1 file cut off mid-diff ({incomplete})")
+    if dropped:
+        tallies.append(f"{len(dropped)} file(s) omitted")
+    if tallies:
+        note += "; " + "; ".join(tallies)
+    note += "] ..."
+    if incomplete:
+        note += (
+            f"\nFile truncated mid-diff — the shown portion of `{incomplete}` "
+            "is INCOMPLETE, not fully reviewed above; inspect the rest "
+            f"directly (e.g. `git show <head-sha> -- {incomplete}`) before "
+            "approving."
+        )
+    if dropped:
+        note += (
+            "\nFiles omitted by truncation — NOT reviewed above; inspect "
+            "these directly (e.g. `git show <head-sha> -- <path>`) before "
+            "approving:\n" + "\n".join(f"  - {p}" for p in dropped)
+        )
+    return head + note
 
 
 def pr_diff(repo_github: str, pr_number: int, *, max_chars: int | None = 60000) -> str | None:

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/coord/providers/claude_pty.py

@@ -582,6 +582,37 @@ class ClaudePtyProvider(Provider):
         # --allowedTools / --permission-mode are still passed as a safety
         # hedge even though enforcement is unverified in the PTY path
         # (capabilities().enforces_deny_list == False).
+        #
+        # #2821: also deliberately NO `--setting-sources user` here, and no
+        # `_claude_md_system_prompt_suffix` embed — both of which
+        # `default_worker_command` (coord/agent.py) DOES use for the `-p`
+        # path. That's not an oversight; it was checked and rejected:
+        #
+        # 1. `--setting-sources user` would exclude the LOCAL settings
+        #    scope, which is exactly where `coord init` (coord/commands/
+        #    setup.py) writes the operator's own `.claude/settings.local.json`
+        #    convenience allow-list (`Bash(coord *)` etc) for the repo
+        #    they're interactively attached to. Restricting sources here
+        #    would silently drop that allow-list for a session the operator
+        #    is watching and expects to behave like their normal `claude`
+        #    session — see coord/agent.py:~4919's identical tradeoff
+        #    written up for the `-p` path (which deliberately keeps the
+        #    default sources reasoning in reverse: it EXCLUDES project/local
+        #    because a worker must NOT inherit host-local settings).
+        # 2. `--bare` would close the CLAUDE.md-ambient-discovery gap
+        #    without touching settings sources, but it also unconditionally
+        #    disables OAuth/keychain reads — this fleet authenticates via
+        #    `claude login`/OAuth, not `ANTHROPIC_API_KEY` (see #2462's
+        #    emergency revert in coord/agent.py for the fleet-wide outage
+        #    that caused). Not usable here either.
+        #
+        # Net effect, measured (#2821): this path pays ~7.7k ambient-
+        # discovery tokens for CLAUDE.md vs. ~5.2k for the `-p` path's
+        # explicit embed — a known, accepted cost of preserving the
+        # operator's own interactive settings on a human-attended session,
+        # not an accident. Revisit if Claude Code ever exposes a way to
+        # suppress CLAUDE.md auto-discovery independent of settings-sources
+        # and `--bare`'s OAuth side effect.
         argv: list[str] = [
             binary,
             "--system-prompt", system_prompt,

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/coord/review.py

@@ -1242,35 +1242,6 @@ def read_repo_claude_md(repo_path: Path) -> str | None:
         return None
 
 
-def _diff_file_paths(diff_text: str) -> list[str]:
-    """Return every file path touched by *diff_text*, deduped, order-preserving.
-
-    Scans unified-diff file-header lines (``diff --git a/X b/Y``, ``---
-    a/X``, ``+++ b/X``) — cheap, dependency-free (#944 sealing v1) ahead of a
-    real diff parser. Shared by :func:`_diff_touched_sealed_paths` (which
-    sealed prefixes) and :func:`_diff_paths_outside_sealed` (which actual
-    paths, #1175 — the test-author/mock-author inverse tamper check needs
-    the offending files, not just which prefixes matched).
-    """
-    paths: list[str] = []
-    seen: set[str] = set()
-    for line in diff_text.splitlines():
-        candidates: list[str] = []
-        if line.startswith("diff --git "):
-            for part in line.split()[1:]:
-                if part.startswith("a/") or part.startswith("b/"):
-                    candidates.append(part[2:])
-        elif line.startswith("--- a/"):
-            candidates.append(line[len("--- a/"):])
-        elif line.startswith("+++ b/"):
-            candidates.append(line[len("+++ b/"):])
-        for c in candidates:
-            if c not in seen:
-                seen.add(c)
-                paths.append(c)
-    return paths
-
-
 def _path_is_sealed(path: str, sealed: str) -> bool:
     """Does *path* fall under the sealed entry *sealed*?
 
@@ -1294,7 +1265,7 @@ def _diff_touched_sealed_paths(diff_text: str, sealed_paths: list[str]) -> list[
     easy to test.
     """
     touched: set[str] = set()
-    for c in _diff_file_paths(diff_text):
+    for c in github_ops.diff_file_paths(diff_text):
         for sealed in sealed_paths:
             if _path_is_sealed(c, sealed):
                 touched.add(sealed)
@@ -1312,7 +1283,7 @@ def _diff_paths_outside_sealed(diff_text: str, sealed_paths: list[str]) -> list[
     the ones inside it.
     """
     return sorted(
-        p for p in _diff_file_paths(diff_text)
+        p for p in github_ops.diff_file_paths(diff_text)
         if not any(_path_is_sealed(p, sealed) for sealed in sealed_paths)
     )
 
@@ -1328,7 +1299,7 @@ def _diff_paths_outside_sealed(diff_text: str, sealed_paths: list[str]) -> list[
 #
 # This is intentionally a coarse, path-only heuristic — no diff semantics, no
 # ``claude -p`` call, no LLM judgment, just the same cheap file-path
-# inspection ``_diff_file_paths``/``_diff_touched_sealed_paths`` already do
+# inspection ``github_ops.diff_file_paths``/``_diff_touched_sealed_paths`` already do
 # above. It is a NUDGE, not a gate: callers only ever log it, never act on it
 # to change dispatch behavior, so a false positive costs nothing (the
 # reviewer remains the sole authority and, per CLAUDE.md, already honors a
@@ -1395,9 +1366,10 @@ def diff_missing_test_coverage(diff_text: str | None) -> bool:
     """#2192: True when *diff_text* touches user-visible source and zero
     test files, the pattern behind 18.5% of #2132's blocking reviews.
 
-    Pure, free, deterministic path inspection — reuses :func:`_diff_file_paths`.
-    Returns False (never flags) when the diff is empty, touches no recognized
-    source file (docs-only/internal-tooling-only diffs — CLAUDE.md's
+    Pure, free, deterministic path inspection — reuses
+    :func:`coord.github_ops.diff_file_paths`. Returns False (never flags)
+    when the diff is empty, touches no recognized source file
+    (docs-only/internal-tooling-only diffs — CLAUDE.md's
     internal-only exemption), or already includes a test-file change.
 
     The CLAUDE.md exemption is honored only at the granularity a path-only
@@ -1413,7 +1385,7 @@ def diff_missing_test_coverage(diff_text: str | None) -> bool:
     """
     if not diff_text or not diff_text.strip():
         return False
-    paths = _diff_file_paths(diff_text)
+    paths = github_ops.diff_file_paths(diff_text)
     if not any(_is_user_visible_path(p) for p in paths):
         return False
     return not any(_is_test_path(p) for p in paths)

{code_coordinator-0.5.247 → code_coordinator-0.5.248}/tests/test_review.py

@@ -1062,6 +1062,84 @@ def test_truncate_diff_text_matches_pr_diff_truncation(monkeypatch) -> None:
     assert via_pr_diff == via_helper
 
 
+def _diff_for(path: str, n_lines: int) -> str:
+    lines = [f"diff --git a/{path} b/{path}", f"--- a/{path}", f"+++ b/{path}"]
+    lines += [f"+line {i}" for i in range(n_lines)]
+    return "\n".join(lines) + "\n"
+
+
+def test_truncate_diff_text_cuts_on_file_boundary_not_mid_hunk() -> None:
+    """#2819: truncation must never hand the reviewer a partial hunk — the
+    cut lands on the last `diff --git` boundary that fits, so every file
+    kept in the output is complete."""
+    from coord import github_ops
+
+    diff = _diff_for("a.py", 20) + _diff_for("b.py", 20) + _diff_for("c.py", 2000)
+    out = github_ops.truncate_diff_text(diff, max_chars=1000)
+
+    # Both kept files are present in full (their own last line included);
+    # nothing stops mid-hunk.
+    assert "+line 19\ndiff --git a/b.py" in out
+    assert "+line 19\n... [diff truncated" in out
+    assert "diff --git a/c.py" not in out
+
+
+def test_truncate_diff_text_lists_omitted_files() -> None:
+    """#2819: a reviewer handed a truncated diff must be told which files
+    it did not see, so it can inspect them directly instead of silently
+    missing them."""
+    from coord import github_ops
+
+    diff = _diff_for("a.py", 20) + _diff_for("b.py", 20) + _diff_for("c.py", 2000)
+    out = github_ops.truncate_diff_text(diff, max_chars=1000)
+
+    assert "1 file(s) omitted" in out
+    assert "Files omitted by truncation" in out
+    assert "  - c.py" in out
+    # Only the dropped file is listed — the kept files aren't flagged as omitted.
+    assert "  - a.py" not in out
+    assert "  - b.py" not in out
+
+
+def test_truncate_diff_text_falls_back_to_char_slice_when_no_boundary_fits() -> None:
+    """#2819: when even the first file's own diff exceeds max_chars (or the
+    input has no `diff --git` boundaries at all), fall back to the old raw
+    character slice rather than emitting an empty string."""
+    from coord import github_ops
+
+    diff = _diff_for("huge.py", 5000)
+    out = github_ops.truncate_diff_text(diff, max_chars=1000)
+
+    assert len(out) > 1000  # head (1000 chars) + trailing note
+    assert out.startswith(diff[:1000])
+    assert "omitted" not in out  # no boundary found -> no file list to report
+
+
+def test_truncate_diff_text_flags_huge_first_file_as_incomplete() -> None:
+    """#2819 follow-up: when the *first* file's own diff already exceeds
+    max_chars, the char-slice fallback used to let it ride into `head`
+    looking complete (its header made it in, so it never appeared on the
+    "omitted" list) while its body was silently cut mid-hunk. A reviewer
+    trusting the omitted-files list would wrongly conclude the huge first
+    file was shown in full. It must now be called out explicitly, distinct
+    from files that were dropped entirely."""
+    from coord import github_ops
+
+    diff = _diff_for("huge.py", 5000) + _diff_for("small.py", 5)
+    out = github_ops.truncate_diff_text(diff, max_chars=1000)
+
+    # The huge first file is cut off mid-hunk, not omitted entirely — it
+    # must be flagged as incomplete rather than silently passing review.
+    assert "huge.py" in out
+    assert "cut off mid-diff" in out
+    assert "INCOMPLETE" in out
+    # The trailing file is genuinely never shown at all — still on the
+    # separate "omitted" list.
+    assert "1 file(s) omitted" in out
+    assert "Files omitted by truncation" in out
+    assert "  - small.py" in out
+
+
 def test_pr_diff_returns_none_on_gh_error(monkeypatch) -> None:
     """#612: pr_diff is best-effort — a gh failure yields None, not a raise."""
     from coord import github_ops
@@ -1928,7 +2006,12 @@ def test_dispatch_review_patch_id_hashes_untruncated_diff(
     # display-truncated copy, so a huge diff still can't blow the briefing.
     assert client.calls, "expected a dispatch POST"
     _, payload = client.calls[0]
-    assert "[diff truncated at 60000 chars]" in payload["briefing"]
+    # #2819 follow-up: f.py is the *only* file and it alone exceeds the cap,
+    # so the char-slice fallback fires and the note now also flags f.py
+    # itself as cut off mid-diff (not just "truncated at N chars") — the
+    # exact fix this test's own issue asked for.
+    assert "[diff truncated at 60000 chars" in payload["briefing"]
+    assert "cut off mid-diff (f.py)" in payload["briefing"]
     assert len(payload["briefing"]) < len(big_diff)