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

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

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

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

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

{code_coordinator-0.5.247 → code_coordinator-0.5.250}/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.250}/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.250}/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.250}/coord/reports.py

@@ -1762,7 +1762,12 @@ _USAGE_COLUMN_META: dict[str, ColumnMeta] = {
     "repo": ColumnMeta(id="repo", label="Repo", kind="text", weight=1.5),
     "title": ColumnMeta(id="title", label="Title", kind="text", weight=4.0),
     "legs": ColumnMeta(id="legs", label="Legs", kind="int", align="right", weight=0.6),
-    "tokens_in": ColumnMeta(id="tokens_in", label="Tok In", kind="int", align="right"),
+    # #2825: labelled "Raw In", not "Tok In" — sitting next to a full "Tok
+    # Out", "Tok In" reads as its matched pair, and it is not: this is raw
+    # UNCACHED input, ~0.001% of what a `work` leg actually sends (the other
+    # ~98% is `cache_read`, below). The column `id` stays `tokens_in` so no
+    # historical number or saved sort changes.
+    "tokens_in": ColumnMeta(id="tokens_in", label="Raw In", kind="int", align="right"),
     "tokens_out": ColumnMeta(id="tokens_out", label="Tok Out", kind="int", align="right"),
     # #2786: the column that carries the money — see module comment above.
     "cache_read": ColumnMeta(id="cache_read", label="Cache Rd", kind="int", align="right"),
@@ -2658,12 +2663,24 @@ COMPLETED_COLUMNS = [
     "title",
     "started_at",
     "ended_at",
-    # #2472's four. Appended, never interleaved: the client addresses columns
-    # by INDEX for sorting (`reports_sort_by_column`), so inserting one in the
-    # middle would silently re-point a saved sort at a different column.
+    # #2472's four, plus #2825's `cache_read`. #2472's own five (`repo`
+    # through `ended_at` above) keep the indices they had — the client
+    # addresses columns by INDEX for sorting (`reports_sort_by_column`), so
+    # THAT boundary is never interleaved. `cost_total` shifting from index 8
+    # to 9 here is accepted, not an oversight: it mirrors `usage`'s own
+    # precedent (#2786 inserted `cache_read`/`cache_create`/`turns` ahead of
+    # `cost_captured`/`cost_est`/`cost_total` there too), and grouping token
+    # counts together beats preserving one more index.
     "legs",
     "tokens_in",
     "tokens_out",
+    # #2825: `cache_read` was already on the wire as a row key (see
+    # `_completed_spend`) — ~98% of a `work` leg's input, sitting next to a
+    # `tokens_in` that is ~0.001% of it. Without this column, `Tok Out`
+    # (uncapped) next to `tokens_in` (raw uncached input) reads as "output
+    # dwarfs input", which is backwards by five orders of magnitude. Reuses
+    # `_USAGE_COLUMN_META`'s `cache_read` verbatim.
+    "cache_read",
     "cost_total",
 ]
 
@@ -2677,10 +2694,14 @@ COMPLETED_COLUMNS = [
 # also what `issue-activity` already does, and what `RowIdentity` reads.
 #
 # #2472's spend columns reuse `_USAGE_COLUMN_META`'s labels/kinds verbatim
-# (`Legs`, `Tok In`, `Tok Out`, `Total $`) rather than inventing near-synonyms:
-# an operator reading `completed` and `usage` side by side is looking at the
-# same numbers out of the same rollup, and two spellings of "Tok In" would
-# imply otherwise.
+# (`Legs`, `Raw In`, `Tok Out`, `Cache Rd`, `Total $`) rather than inventing
+# near-synonyms: an operator reading `completed` and `usage` side by side is
+# looking at the same numbers out of the same rollup, and two spellings of
+# the same column would imply otherwise.
+#
+# #2825: `tokens_in` is labelled "Raw In", not "Tok In" — see the comment on
+# `_USAGE_COLUMN_META["tokens_in"]` for why. Applied here too so the two
+# reports keep agreeing.
 #
 # ONE cost column, not `usage`'s `cost_captured`/`cost_est` split. `usage`
 # splits because it is the dedicated cost report, where "some legs have no
@@ -2689,7 +2710,9 @@ COMPLETED_COLUMNS = [
 # would push `title` off a narrow pane. Both halves still ship as extra ROW
 # keys (see `_completed_spend`) — the wire contract allows row keys beyond
 # `columns`, so a client that wants the split has it without another column,
-# and `usage` remains the report to visit for it on screen.
+# and `usage` remains the report to visit for it on screen. `cache_read` is
+# the one exception (#2825): it isn't a split of an existing column, it's the
+# ~98% of input spend that `tokens_in` alone cannot represent.
 COMPLETED_COLUMN_META = [
     ColumnMeta(id="repo", label="Repo", kind="text"),
     ColumnMeta(id="issue", label="Issue", kind="int", align="right"),
@@ -2697,8 +2720,9 @@ COMPLETED_COLUMN_META = [
     ColumnMeta(id="started_at", label="Started", kind="timestamp"),
     ColumnMeta(id="ended_at", label="Ended", kind="timestamp"),
     ColumnMeta(id="legs", label="Legs", kind="int", align="right", weight=0.6),
-    ColumnMeta(id="tokens_in", label="Tok In", kind="int", align="right"),
+    ColumnMeta(id="tokens_in", label="Raw In", kind="int", align="right"),
     ColumnMeta(id="tokens_out", label="Tok Out", kind="int", align="right"),
+    ColumnMeta(id="cache_read", label="Cache Rd", kind="int", align="right"),
     ColumnMeta(id="cost_total", label="Total $", kind="money", align="right"),
 ]
 

{code_coordinator-0.5.247 → code_coordinator-0.5.250}/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.250}/tests/test_reports.py

@@ -2635,6 +2635,18 @@ class TestUsageSurfacesCacheReadAndTurns:
         # (100 + 100 + 800 + 0) / 10 = 100.
         assert result.rows[0]["tok_per_turn"] == 100
 
+    def test_tokens_in_is_labelled_raw_in_not_tok_in(self) -> None:
+        """#2825: "Tok In" next to a full "Tok Out" reads as a matched pair —
+        it is not one, `tokens_in` is ~0.001% of real input. The column `id`
+        stays `tokens_in` (no historical number or saved sort changes), only
+        the display `label` moves."""
+        from coord.reports import fold_usage
+
+        result = fold_usage(_usage_fixture_rows(), _unbounded_window())
+        meta = {m.id: m for m in result.column_meta}
+        assert meta["tokens_in"].label == "Raw In"
+        assert meta["tokens_out"].label == "Tok Out"
+
     def test_totals_row_also_carries_the_new_columns(self) -> None:
         from coord.reports import fold_usage
 
@@ -4182,7 +4194,10 @@ class TestCompletedFold:
             "repo", "issue", "title", "started_at", "ended_at",
             # #2472's four, APPENDED — the client sorts by column index, so
             # #2454's five must keep the indices they had.
-            "legs", "tokens_in", "tokens_out", "cost_total",
+            # #2825's `cache_read`, appended after `tokens_out` (before
+            # `cost_total`, which shifts by one index — see the module
+            # comment).
+            "legs", "tokens_in", "tokens_out", "cache_read", "cost_total",
         ]
         assert [m.id for m in result.column_meta] == result.columns
 
@@ -4298,6 +4313,33 @@ class TestCompletedSpend:
         # captured cost so its 1M sonnet input tokens estimate to $3.00.
         assert row["cost_total"] == pytest.approx(5.0)
 
+    def test_cache_read_is_a_declared_column_not_just_a_row_key(self) -> None:
+        """#2825: `completed` showed a full `Tok Out` next to a `tokens_in`
+        that is ~0.001% of a leg's real input — the raw uncached count sitting
+        alone next to output read as "output dwarfs input", backwards by five
+        orders of magnitude. `cache_read` was already computed into every row
+        by `_usage_metrics`; this only had to become a declared column.
+        """
+        result = fold_completed(
+            [{"repo_name": "myrepo", "number": 21, "title": "t", "state": "closed"}],
+            [{"repo_name": "myrepo", "issue_number": 21,
+              "dispatched_at": 10.0, "finished_at": 20.0, "model": "sonnet",
+              "input_tokens": 634, "output_tokens": 186_209,
+              "cache_read_tokens": 59_908_777}],
+            [],
+            (C_START, C_END),
+            generated_at=C_END,
+        )
+        assert "cache_read" in result.columns
+        meta = {m.id: m for m in result.column_meta}
+        assert meta["cache_read"].label == "Cache Rd"
+        row = result.rows[0]
+        assert row["tokens_in"] == 634
+        assert row["tokens_out"] == 186_209
+        # The number that actually carries the input volume — orders of
+        # magnitude above `tokens_in`, exactly the #2825 scenario.
+        assert row["cache_read"] == 59_908_777
+
     def test_the_captured_estimated_split_ships_as_extra_row_keys(self) -> None:
         """One `Total $` COLUMN, but no information thrown away — a client
         that wants `usage`'s split can read it off the row."""
@@ -4384,7 +4426,7 @@ class TestCompletedSpend:
             if peer is None:
                 assert row["legs"] == 0, "only a no-leg issue may be absent from usage"
                 continue
-            for key in ("legs", "tokens_in", "tokens_out"):
+            for key in ("legs", "tokens_in", "tokens_out", "cache_read"):
                 assert row[key] == peer[key], f"{row['repo']}#{row['issue']} {key}"
             assert row["cost_total"] == pytest.approx(peer["cost_total"])
             checked += 1
@@ -4646,14 +4688,17 @@ class TestCompletedCatalogue:
         text = result_to_csv(_fold_completed())
         # The header row is the `column_meta` LABELS (the shared serializer's
         # rule), and the values stay raw epochs — not display strings.
-        # #2472's four labels are `usage`'s verbatim, so a spreadsheet built
-        # off one export lines up with the other.
-        assert "Repo,Issue,Title,Started,Ended,Legs,Tok In,Tok Out,Total $" in text
-        # myrepo#9 merged with no assignment: a real 0/0/0/0.0, not four
+        # #2472's four labels (plus #2825's `cache_read`) are `usage`'s
+        # verbatim, so a spreadsheet built off one export lines up with the
+        # other. `tokens_in` is labelled "Raw In", not "Tok In" (#2825) — it
+        # is not `Tok Out`'s pair, it's ~0.001% of a leg's real input.
+        assert "Repo,Issue,Title,Started,Ended,Legs,Raw In,Tok Out,Cache Rd,Total $" in text
+        # myrepo#9 merged with no assignment: a real 0/0/0/0/0.0, not five
         # empty cells.
-        assert 'myrepo,9,"Merged, still open",,400.0,0,0,0,0.0' in text
-        # myrepo#7's retry: 2 legs, $2.00 captured + $3.00 estimated.
-        assert "myrepo,7,Closed one,100.0,250.0,2,1000010,4,5.0" in text
+        assert 'myrepo,9,"Merged, still open",,400.0,0,0,0,0,0.0' in text
+        # myrepo#7's retry: 2 legs, $2.00 captured + $3.00 estimated, no
+        # cache_read_tokens in the fixture so that column reads 0.
+        assert "myrepo,7,Closed one,100.0,250.0,2,1000010,4,0,5.0" in text
 
 
 class TestRowIdentity:

{code_coordinator-0.5.247 → code_coordinator-0.5.250}/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)
 
 

{code_coordinator-0.5.247 → code_coordinator-0.5.250}/tui/src/app/fixtures.rs

@@ -141,7 +141,19 @@ pub fn make_test_app(data: BoardData) -> CoordApp {
         chat_transcript_cache_key: None,
         chat_last_activity: None,
         chat_spinner_throttle: 0,
-        paused_machines: read_paused_machines(),
+        // #2028: never call the real `read_paused_machines()` from a test
+        // fixture — it reads the LOCAL `~/.coord/paused_machines.json`
+        // unconditionally (mirrors `workspace` above: no real I/O). Before
+        // this, any host whose real pause file was non-empty (e.g. two
+        // long-destroyed ephemeral workers left paused on dellserver since
+        // 2026-08-04) failed `poll_paused_machines_replaces_snapshot_when_ready`
+        // and `..._reverts_an_operator_pause_..` (`app/tests.rs`) purely from
+        // ambient machine state — both tests assert `paused_machines.is_empty()`
+        // immediately after construction. Empty here matches what every
+        // caller of this fixture already expects; a test that wants a
+        // pre-populated set assigns `app.paused_machines` directly (see the
+        // tests further down this file).
+        paused_machines: std::collections::HashSet::new(),
         quiet_paused_machines: std::collections::HashSet::new(),
         cordoned_machines: std::collections::HashSet::new(),
         quiet_hours_windows: std::collections::HashMap::new(),

{code_coordinator-0.5.247 → code_coordinator-0.5.250}/tui/src/app/mod.rs

@@ -9756,12 +9756,15 @@ fn today_yyyy_mm_dd() -> String {
 ///
 /// #1563: on a thin client (board service configured) this file is no
 /// longer authoritative — `coord pause` on such a client now writes
-/// straight to the daemon instead. `CoordApp::new`/`make_test_app` still
-/// call this directly for the *initial* synchronous `paused_machines`
-/// snapshot (mirroring `live_tmux_sessions`/`fleet_terminals`/
-/// `drive_sessions` further up this file, each seeded from a cheap local
-/// read before their background remote sweep is armed), but every
-/// *periodic* refresh after that goes through
+/// straight to the daemon instead. `CoordApp::new` still calls this
+/// directly for the *initial* synchronous `paused_machines` snapshot
+/// (mirroring `live_tmux_sessions`/`fleet_terminals`/`drive_sessions`
+/// further up this file, each seeded from a cheap local read before their
+/// background remote sweep is armed). `app::fixtures::make_test_app`
+/// deliberately does NOT call this (#2028) — a test fixture must never
+/// read ambient machine state, so it seeds `paused_machines` empty instead
+/// and lets individual tests assign it directly. Every *periodic* refresh
+/// after startup goes through
 /// [`data::fetch_paused_machines`] / [`data::spawn_paused_machines_fetch`]
 /// instead, which route to the daemon's `GET /pause` when a board service
 /// is configured and fall back to this function otherwise — so a