code-coordinator 0.5.264__tar.gz → 0.5.267__tar.gz

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.264",
+  "tag": "0.5.267",
   "distance": 0,
-  "node": "g037604ea4782108f989df77750337682d26f2a36",
+  "node": "g1fa630fb3cebe560405cb33c1b2ce1e3fed742a4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-28"

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/coord/board_wire.py

@@ -15,14 +15,12 @@ This module is the single place the per-field wire policy lives:
   with ``<field>_truncated: true`` (+ ``<field>_len``).  Consumers that need
   the full text (fix-worker briefings, the TUI findings pane) fetch the
   single-resource detail endpoint ``GET /assignment/{id}``.
-* **Bounded documents** — ``issues.body``, ``test_plan`` — get a *high* hard
-  cap that today truncates nothing real (issue-body p99 ≈ 9 KB, cap 16 KB)
-  but bounds the pathological row, because clients parse these semantically
-  (work orders, ``## Files`` globs) and an aggressive prefix cut would break
-  those parses.  **Tracking (epic) issue bodies are exempt entirely** — the
-  TUI's Milestone DAG parses ``## Work order`` client-side out of the full
-  body (see :func:`bound_issue_row`); GitHub's own 64 KB issue-body limit ×
-  the handful of epics per board keeps the exemption bounded.  Full body:
+* **Bounded documents** — ``test_plan`` — get a *high* hard cap that today
+  truncates nothing real but bounds the pathological row, because clients
+  parse these semantically and an aggressive prefix cut would break those
+  parses.
+* **``issues.body`` is not on the collection wire at all** (#1939), except
+  for tracking (epic) issues.  See :func:`bound_issue_row`.  Full body:
   ``GET /issue/{repo}/{number}``.
 
 Everything here is wire-only: the DB row, the detail endpoints, and local
@@ -49,6 +47,24 @@ issues outright, on top of the existing per-field width caps. Both cuts are
 flagged on the payload (``board_truncated`` + counts) so a client can tell
 it received a trimmed board rather than the whole history — see
 :func:`bound_board_payload`.
+
+**#1939 (instance #5): the 16 KB body cap bounded the pathological row and
+nothing else.** #1337 gave ``issues.body`` a *document* cap high enough that
+it truncates no real issue (p99 ≈ 9 KB against a 16 KB cap), and #1791 then
+dropped the body of *closed* issues outright.  What was left — every **open,
+non-epic** body, shipped whole on every uncached poll — was still 1.44 MB of
+a 1.69 MB issue-body payload measured on the live board, for a field that is
+display material, not something a collection *view* renders directly: the
+TUI reads it lazily, on demand, through several panes that share the same
+``issue_detail_cache`` / ``GET /issue/{repo}/{number}`` hydration path (the
+Board and Pipeline Issue tabs since #2497; the Drive/Merge Queue tab's
+issue-detail pane and the "Chat about issue" briefing as of this fix) rather
+than each parsing the wire body eagerly. Do not assume the Board/Pipeline
+tabs are the only consumers when touching this policy again — check every
+Rust call site of ``OpenIssue.body`` / ``PipelineIssue.body`` first. So the
+body now leaves the collection wire for open issues too, and
+:func:`bound_issue_row` keeps only the machine-parsed *residue* a client
+cannot re-fetch in time — see :data:`ALLOWED_GLOB_MARKER`.
 """
 
 from __future__ import annotations
@@ -88,6 +104,27 @@ BOARD_PAYLOAD_BYTE_BUDGET = 2_500_000
 # (TUI pane, dialog) knows it is one — machine consumers use the flags.
 TRUNCATION_NOTICE = "\n… [truncated on the /board wire — full text: detail endpoint]"
 
+# #1939: the ONE line-level marker a thin client parses out of a non-epic
+# issue body *synchronously*, without a user action that could wait for a
+# detail fetch — `tui/src/app/pipeline.rs`'s
+# `parse_allowed_globs_from_issue_body` MARKER, read by
+# `acceptance_for_path_arg` while handling a Pipeline right-click dispatch on
+# a repo with more than one acceptance route (`claude-coordinator` itself has
+# two: `coord/**` and `tui/**`). Lines carrying it survive the body cut; see
+# `_machine_readable_residue`. Kept in sync with the Rust side by
+# tests/test_board_wire.py::test_allowed_glob_marker_matches_the_rust_parser,
+# the same cross-language guard posture as coord/board_bool_guard.py.
+#
+# Measured cost of the retention: ZERO on today's live board — 0 of 781
+# issue bodies carry the marker (the house `## Files` convention is a bare
+# backticked-path list, which that parser does not read), so the residue is
+# empty for every real row and the byte win below is unaffected. It is kept
+# anyway because the marker IS the documented spelling
+# (`parse_allowed_globs_from_issue_body`'s own tests use it) and a body that
+# adopts it must keep resolving `--for-path` from the Pipeline right-click
+# rather than silently degrading to "dispatch from the CLI instead".
+ALLOWED_GLOB_MARKER = "**Allowed:**"
+
 
 def _preview(text: str, cap: int) -> str:
     return text[:cap] + TRUNCATION_NOTICE
@@ -150,8 +187,31 @@ def _bound_test_plan(row: dict, cap: int) -> None:
     row["test_plan"] = None
 
 
+#: table → every field this module may stamp ``<field>_truncated`` /
+#: ``<field>_len`` onto.  Those flags are **wire-only**: they are not DB
+#: columns, so they are deliberately absent from the DTOs in
+#: ``coord/board_schema.py`` (whose rule — "a column not declared here is not
+#: on the wire" — is about *columns*).  They are still on the wire, so
+#: ``coord/serve_app.py``'s ``_board_payload_schema`` publishes them off this
+#: table; before #1939 made issue-body bounding unconditional they fired
+#: rarely enough that ``/openapi.json`` never had to admit they existed.
+BOUNDED_TEXT_FIELDS: dict[str, tuple[str, ...]] = {
+    "assignments": (
+        "review_findings",
+        "test_reason",
+        "smoke_test_reason",
+        "failure_reason",
+        "test_plan",
+    ),
+    "issues": ("body",),
+}
+
+
 def bound_assignment_row(row: dict) -> None:
-    """Apply the wire policy to one ``/board`` assignment row (mutates)."""
+    """Apply the wire policy to one ``/board`` assignment row (mutates).
+
+    Every field it may bound is listed in :data:`BOUNDED_TEXT_FIELDS`.
+    """
     _bound_review_findings(row, PREVIEW_CHARS)
     _bound_text_field(row, "test_reason", PREVIEW_CHARS)
     _bound_text_field(row, "smoke_test_reason", PREVIEW_CHARS)
@@ -172,6 +232,26 @@ def _is_closed_issue(row: dict) -> bool:
     return isinstance(state, str) and state.strip().lower() == "closed"
 
 
+def _machine_readable_residue(body: str) -> str:
+    """The lines of *body* a **client** parses without a user action, joined
+    back together (#1939).
+
+    Everything else in a non-epic body is display material, and the Issue
+    tab re-fetches that from ``GET /issue/{repo}/{number}`` on demand.  What
+    cannot be re-fetched in time is the ``## Files`` glob declaration that
+    ``acceptance_for_path_arg`` reads *synchronously* while handling a
+    right-click dispatch — so those lines, and only those, stay inline.
+
+    Line-scoped by construction: the Rust parser matches
+    :data:`ALLOWED_GLOB_MARKER` per line and reads only the backtick spans
+    that follow it on that same line, so retaining whole matching lines is
+    exactly equivalent to retaining the whole body as far as it can tell.
+    """
+    return "".join(
+        f"{line}\n" for line in body.splitlines() if ALLOWED_GLOB_MARKER in line
+    )
+
+
 def bound_issue_row(row: dict) -> None:
     """Apply the wire policy to one ``/board`` issue row (mutates).
 
@@ -183,24 +263,57 @@ def bound_issue_row(row: dict) -> None:
     work-order items past DOCUMENT_CHARS would silently drop DAG nodes on
     thin clients — a regression in exactly the failure class #1337 exists to
     close.  The exemption stays bounded in practice: an epic body is capped
-    at 65,536 chars by GitHub itself and boards carry few epics (~31 today,
-    0.19 MB total).
+    at 65,536 chars by GitHub itself and boards carry few epics (48 open
+    today, 0.24 MB total).
 
     **Closed (non-epic) issues drop the body entirely** (#1791): a closed
     issue is terminal — no pipeline decision, client-side or server-side,
-    reads its body once it's closed — and #1337's DOCUMENT_CHARS cap alone
-    still left 110 closed issues carrying 0.57 MB on every /board GET. Full
-    text stays on ``GET /issue/{repo}/{number}``. Open (non-epic) issue
-    bodies — the ones ``pipeline.rs``'s ``acceptance_for_path_arg`` and
-    ``dialogs.rs`` parse client-side — keep the DOCUMENT_CHARS cap
-    unchanged.
+    reads its body once it's closed.
+
+    **Open (non-epic) issues keep only the machine-parsed residue** (#1939).
+    The rest of an open body is display material, and every Rust consumer of
+    the synced row (the Board/Pipeline Issue tabs since #2497; the
+    Drive/Merge Queue tab's issue-detail pane and the "Chat about issue"
+    briefing as of this fix) hydrates it lazily from
+    ``GET /issue/{repo}/{number}`` instead — so shipping it inline was
+    1.44 MB per uncached poll, per client, for text nothing renders until a
+    user opens one issue.  ``body_truncated`` + ``body_len`` are stamped
+    exactly as for a closed issue, which is what arms that hydration
+    (``pipeline.rs::issue_body_fetch_target``).
     """
     if _is_tracking_issue(row):
         return
     if _is_closed_issue(row):
         _bound_text_field(row, "body", 0)
         return
-    _bound_text_field(row, "body", DOCUMENT_CHARS)
+    _bound_open_issue_body(row)
+
+
+def _bound_open_issue_body(row: dict) -> None:
+    """#1939: replace an open non-epic ``body`` with its machine-readable
+    residue + the truncation notice, stamping the same
+    ``body_truncated``/``body_len`` flags :func:`_bound_text_field` does.
+
+    A body whose residue is not actually smaller than the original (a body
+    that *is* one ``**Allowed:**`` line, or an empty one) is left alone
+    rather than flagged — same "nothing was cut, so the shape is unchanged"
+    rule the width caps follow.
+    """
+    val = row.get("body")
+    if not isinstance(val, str) or not val:
+        return
+    residue = _machine_readable_residue(val)
+    # Backstop for a pathological body that is nothing but glob declarations
+    # — can't happen with a real issue, but the point of this module is that
+    # no collection field is unbounded.
+    if len(residue) > DOCUMENT_CHARS:
+        residue = residue[:DOCUMENT_CHARS]
+    replacement = residue + TRUNCATION_NOTICE
+    if len(replacement) >= len(val):
+        return
+    row["body_len"] = len(val)
+    row["body_truncated"] = True
+    row["body"] = replacement
 
 
 def _open_issue_keys(issues) -> set[tuple[str, int]]:

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/coord/commands/release.py

@@ -653,10 +653,22 @@ def _lane_versions_by_host(report) -> dict[str, list[str | None]]:
     return out
 
 
-def _ensure_roll_pending_marker(target_version: str, *, reason: str) -> None:
+def _ensure_roll_pending_marker(
+    target_version: str, *, reason: str, dry_run: bool = False
+) -> None:
     """#2587: make sure a roll-pending marker exists for *target_version*,
     without resetting an already-live one's clock.
 
+    #2869: ``dry_run=True`` is the ONE seam every call site must go through —
+    it never touches disk, only echoing what it *would* have written, in the
+    same "would ..." register as ``_fire_pending_roll``'s and
+    ``_apply_cordons``'s own dry-run wording. A caller-side ``if dry_run:``
+    guard around the call site was tried first and is exactly what let this
+    bug happen: the marker write is the one state mutation on the #2587
+    defer branch that never got that guard. Folding the check in here means
+    a future second call site inherits the guard for free instead of having
+    to remember to add its own.
+
     Called from the one place `coord release propagate` itself hits the
     #2112 daemon-busy deadlock it cannot roll through on its own (the
     daemon-first ``busy_hosts`` check in :func:`release_propagate`) — so a
@@ -692,10 +704,24 @@ def _ensure_roll_pending_marker(target_version: str, *, reason: str) -> None:
     if existing is not None and existing.target_version == target_version:
         return
     if existing is not None:
+        if dry_run:
+            click.echo(
+                f"--dry-run: would replace the pending roll-pending marker "
+                f"({existing.describe()}) with v{target_version} (reason="
+                f"{reason!r}), preserving its original set_at/deferrals (#2607)"
+            )
+            return
         write_roll_pending(
             _dataclasses.replace(existing, target_version=target_version, reason=reason)
         )
         return
+    if dry_run:
+        click.echo(
+            f"--dry-run: would set a roll-pending marker for v{target_version} "
+            f"(reason={reason!r}) — the drive-queue tick would then hold "
+            "capacity at 0 until the queue drains"
+        )
+        return
     write_roll_pending(
         RollPending(target_version=target_version, set_at=_time.time(), reason=reason)
     )
@@ -1097,7 +1123,7 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
         # too, so a plain periodic `coord-release-propagate.timer` run also
         # arms the drive-queue tick's own inter-drive-gap trigger instead of
         # requiring an operator to separately reach for `nightly-window`.
-        _ensure_roll_pending_marker(record.target_version, reason="propagate")
+        _ensure_roll_pending_marker(record.target_version, reason="propagate", dry_run=dry_run)
         _finish(rp.STATUS_DEFERRED, 0)
 
     still_busy = busy_hosts - set(current)

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/coord/serve_app.py

@@ -2303,6 +2303,45 @@ def _board_response_schema(components: dict) -> dict:
     for cls in board_schema.BOARD_PROJECTIONS.values():
         dataclass_schema(cls, components)
 
+    # #1939: `coord.board_wire` stamps `<field>_truncated` / `<field>_len`
+    # onto bounded rows *after* the DTO projection. They are wire-only (no DB
+    # column backs them), so they are not — and should not be — DTO fields;
+    # but they ARE on the wire, and since #1939 made issue-body bounding
+    # unconditional EVERY open non-epic issue carries them, where before they
+    # fired rarely enough that nothing noticed the spec omitted them.
+    # Declared off board_wire's own field table so the published schema stays
+    # a superset of what /board emits (asserted by
+    # tests/test_board_schema.py::test_board_dtos_and_projection_cannot_drift).
+    #
+    # Only `issues` is published here, not board_wire's whole
+    # BOUNDED_TEXT_FIELDS table. `assignments`' four remaining flag pairs
+    # (test_reason/smoke_test_reason/failure_reason/test_plan — review_findings
+    # is already hand-declared on the Rust side) are the same pre-existing
+    # omission, but they are not what #1939 changed, and declaring them makes
+    # `scripts/codegen.py --rust` emit eight new `Assignment` fields, which
+    # forces ~380 lines of struct-literal churn across 48 fixture sites for a
+    # diff about /board byte size. Left for its own change.
+    from coord.board_wire import BOUNDED_TEXT_FIELDS  # noqa: PLC0415
+
+    for _table, _fields in ((t, BOUNDED_TEXT_FIELDS[t]) for t in ("issues",)):
+        _props = components[board_schema.BOARD_PROJECTIONS[_table].__name__]["properties"]
+        for _field in _fields:
+            _props[f"{_field}_truncated"] = {
+                "type": "boolean",
+                "description": (
+                    f"#1337/#1939: true when the /board wire bounded `{_field}`. "
+                    "Additive-only — absent (not false) when nothing was cut. "
+                    "Fetch the full value from the single-resource detail read."
+                ),
+            }
+            _props[f"{_field}_len"] = {
+                "type": "integer",
+                "description": (
+                    f"#1337/#1939: `{_field}`'s full length before bounding. "
+                    f"Present only alongside `{_field}_truncated`."
+                ),
+            }
+
     planned_merge_ref = dataclass_schema(PlannedMerge, components)
     staging_item_ref = dataclass_schema(StagingItem, components)
 

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/scripts/codegen.py

@@ -1050,12 +1050,15 @@ RUST_EXTRA_FIELDS: dict[str, tuple[RustField, ...]] = {
         RustField(
             name="body_truncated", ty="bool", serde=("default",),
             doc=(
-                "#2497: true when the `/board` wire bounded `body` — set for a closed",
-                "(non-epic) issue, whose body `board_wire.bound_issue_row` drops to 0",
-                "chars (#1791). `#[serde(default)]` so an older daemon (pre-#2497,",
-                "never stamps this) deserializes as `false` — the pre-existing",
-                "behavior of trusting `body` verbatim. Absent for open/epic issues,",
-                "whose bodies the wire never truncates to 0.",
+                "#2497: true when the `/board` wire bounded `body`. Set for every",
+                "NON-EPIC issue, closed or open: `board_wire.bound_issue_row` drops a",
+                "closed body to 0 chars (#1791) and an open one to its machine-parsed",
+                "`**Allowed:**` residue (#1939), because the Issue tabs hydrate the",
+                "real text lazily from `GET /issue/{repo}/{number}`. Absent only for",
+                "epic bodies, which stay inline for the client-side Milestone DAG",
+                "parse. `#[serde(default)]` so an older daemon (pre-#2497, never",
+                "stamps this) deserializes as `false` — the pre-existing behavior of",
+                "trusting `body` verbatim.",
                 "",
                 "Not part of `coord.board_schema.BoardIssue` — stamped onto the row",
                 "afterward by `coord/board_wire.py`; kept here by hand alongside its",
@@ -1142,10 +1145,22 @@ def emit_rust_struct(schema_name: str, rust_name: str, schemas: dict[str, Any])
     lines.extend(meta["attrs"])
     lines.append(f"#[derive({', '.join(meta['derives'])})]")
     lines.append(f"{meta['vis']} struct {rust_name} {{")
+    extras = RUST_EXTRA_FIELDS.get(rust_name, ())
+    # #1939: an extras entry WINS over the mechanical walk when the spec also
+    # declares that property. `RUST_EXTRA_FIELDS` exists for the wire-only
+    # `<field>_truncated`/`<field>_len` flags `board_wire.py` stamps on, and
+    # `/openapi.json` now declares them too (it always should have — they were
+    # just rare enough on the wire that nothing noticed). Without this the walk
+    # and the table would BOTH emit them: duplicate struct fields, and the
+    # auto-derived `body_len: i64` would shadow the hand-written
+    # `Option<i64>` that `issue_body_fetch_target`'s `len?` gate depends on.
+    extra_names = {f.name for f in extras}
     for python_name, field_schema in properties.items():
+        if python_name in extra_names:
+            continue
         field = overrides.get(python_name) or _rust_auto_field(python_name, field_schema)
         lines.extend(_render_rust_field(field))
-    for field in RUST_EXTRA_FIELDS.get(rust_name, ()):
+    for field in extras:
         lines.extend(_render_rust_field(field))
     lines.append("}")
     return "\n".join(lines)

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/tests/test_board_read_path.py

@@ -975,16 +975,17 @@ def test_board_wire_bounds_assignment_text_fields(app_client: TestClient) -> Non
 
 
 def test_board_wire_bounds_issue_bodies(app_client: TestClient) -> None:
-    """Issue bodies get the high document cap (semantic parses — work orders,
-    ## Files globs — must survive for every real body; today p99 ≈ 9 KB)."""
-    from coord.board_wire import DOCUMENT_CHARS
+    """#1939: an open non-epic body leaves the collection wire entirely — it
+    is 1.44 MB of display material the Issue tabs hydrate lazily (#2497) —
+    and is flagged so a client knows to fetch the detail read."""
+    from coord.board_wire import TRUNCATION_NOTICE
 
     board = app_client.get("/board").json()
     issue = next(i for i in board["issues"] if i["number"] == 42)
-    # 9 KB body is under the document cap: served whole, no flag.
-    assert issue["body"] == "B" * 9000
-    assert "body_truncated" not in issue
-    assert DOCUMENT_CHARS >= 16384
+    # 9 KB body: no longer served on the collection wire at all.
+    assert issue["body"] == TRUNCATION_NOTICE
+    assert issue["body_truncated"] is True
+    assert issue["body_len"] == 9000
 
 
 def test_board_wire_short_fields_untouched(

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/tests/test_board_wire.py

@@ -18,6 +18,7 @@ flag so a client can tell it received a trimmed board.
 from __future__ import annotations
 
 import json
+import re
 import sqlite3
 import time
 from pathlib import Path
@@ -142,15 +143,104 @@ def test_bound_issue_row_drops_closed_issue_body() -> None:
     assert len(row["body"]) < 200  # notice text only — no prefix survives
 
 
-def test_bound_issue_row_open_issue_keeps_document_cap() -> None:
-    """Unchanged #1337 behaviour: OPEN non-epic issues keep the DOCUMENT_CHARS
-    prefix, not a hard drop — coord-tui's client-side parses need it."""
-    from coord.board_wire import DOCUMENT_CHARS
+def test_bound_issue_row_drops_open_non_epic_issue_body() -> None:
+    """#1939: an OPEN non-epic body is display material the Issue tabs
+    hydrate lazily (#2497), so it leaves the collection wire too — the
+    #1337 DOCUMENT_CHARS prefix truncated no real issue (p99 ≈ 9 KB against
+    a 16 KB cap) and therefore saved nothing."""
+    body = "x" * 9000
+    row = {"state": "open", "labels": ["bug"], "body": body}
+    bound_issue_row(row)
+    assert row["body_truncated"] is True
+    assert row["body_len"] == 9000
+    assert len(row["body"]) < 200  # notice text only
+    assert "x" * 100 not in row["body"]
+
+
+def test_bound_issue_row_open_body_keeps_the_allowed_globs_line() -> None:
+    """#1939: `acceptance_for_path_arg` parses `**Allowed:**` out of an open
+    issue's body SYNCHRONOUSLY while handling a Pipeline right-click
+    dispatch — there is no user action it could wait for a detail fetch
+    behind — so those lines survive the cut while the prose does not."""
+    body = (
+        "Some long prose that nothing parses.\n" * 200
+        + "## Files\n"
+        + "- **Allowed:** `coord/board_wire.py`, `tests/test_board_wire.py`\n"
+        + "- **Forbidden:** docs/README.\n"
+        + "More prose.\n" * 200
+    )
+    row = {"state": "open", "labels": ["bug"], "body": body}
+    bound_issue_row(row)
+
+    assert row["body_truncated"] is True
+    assert row["body_len"] == len(body)
+    assert "**Allowed:** `coord/board_wire.py`, `tests/test_board_wire.py`" in row["body"]
+    assert "Some long prose" not in row["body"]
+    assert "Forbidden" not in row["body"]
+    assert len(row["body"]) < len(body) // 10
+
+
+def test_bound_issue_row_open_body_of_only_globs_is_left_alone() -> None:
+    """Additive-only rule: when the residue isn't actually smaller than the
+    original, nothing is cut and no flag is stamped — an old client sees an
+    unchanged shape, same as the width caps."""
+    body = "- **Allowed:** `coord/**`\n"
+    row = {"state": "open", "labels": ["bug"], "body": body}
+    bound_issue_row(row)
+    assert row["body"] == body
+    assert "body_truncated" not in row
+
 
-    row = {"state": "open", "labels": ["bug"], "body": "x" * (DOCUMENT_CHARS + 500)}
+def test_bound_issue_row_short_open_body_still_dropped() -> None:
+    """A *short* open body is still not free: 490 open non-epic issues at a
+    ~2.9 KB mean were 1.44 MB per uncached poll, per client. The cut is
+    unconditional, not size-gated."""
+    body = "a short but entirely unrendered issue description\n" * 5
+    row = {"state": "open", "labels": ["bug"], "body": body}
     bound_issue_row(row)
     assert row["body_truncated"] is True
-    assert len(row["body"]) > DOCUMENT_CHARS  # prefix + notice, not dropped to ~0
+    assert "unrendered" not in row["body"]
+
+
+def test_bound_issue_row_empty_open_body_untouched() -> None:
+    row = {"state": "open", "labels": ["bug"], "body": ""}
+    bound_issue_row(row)
+    assert row["body"] == ""
+    assert "body_truncated" not in row
+
+
+def test_bound_issue_row_open_epic_body_still_inline() -> None:
+    """#1939 must not reach the Milestone DAG: `milestone_dag.rs` parses
+    `## Work order` client-side out of the epic body with NO extra
+    round-trip, so epics stay exempt (48 open epics, 0.24 MB — bounded)."""
+    body = "## Work order\n" + "x" * 20000 + "\n- [ ] #4243 {after: #4242}\n"
+    row = {"state": "open", "labels": ["epic", "coord"], "body": body}
+    bound_issue_row(row)
+    assert row["body"] == body
+    assert "body_truncated" not in row
+
+
+def test_allowed_glob_marker_matches_the_rust_parser() -> None:
+    """Cross-language guard (#1939), same posture as coord/board_bool_guard.py:
+    `ALLOWED_GLOB_MARKER` decides what survives the body cut on the *server*,
+    but the consumer that needs it is `parse_allowed_globs_from_issue_body`
+    in the Rust TUI. If someone renames the marker on one side only, the
+    residue silently stops carrying what the client parses — so assert the
+    two spellings are still the same string.
+    """
+    from coord.board_wire import ALLOWED_GLOB_MARKER
+
+    src = Path(__file__).resolve().parents[1] / "tui" / "src" / "app" / "pipeline.rs"
+    if not src.exists():  # pragma: no cover — coord installed without the TUI tree
+        pytest.skip("tui/src/app/pipeline.rs not present in this checkout")
+    text = src.read_text(encoding="utf-8")
+    marker = re.search(r'const MARKER: &str = "([^"]+)";', text)
+    assert marker is not None, (
+        "parse_allowed_globs_from_issue_body's MARKER const is gone or was "
+        "reshaped — re-check what the Rust side parses before trusting "
+        "_machine_readable_residue"
+    )
+    assert marker.group(1) == ALLOWED_GLOB_MARKER
 
 
 def test_bound_issue_row_closed_epic_still_exempt() -> None:

{code_coordinator-0.5.264 → code_coordinator-0.5.267}/tests/test_cli_release_propagate.py

@@ -459,6 +459,42 @@ def test_a_busy_daemon_host_defers_the_whole_run(
     assert pending.reason == "propagate"
 
 
+def test_a_busy_daemon_dry_run_defers_without_writing_the_marker(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2869: `--dry-run` promises to "print the window verdict and the roll
+    plan; change nothing" — but the daemon-busy defer branch above called
+    `_ensure_roll_pending_marker` unconditionally, so a purely read-only
+    `coord release propagate --dry-run` against a busy daemon armed the
+    REAL #2587 roll-pending marker, freezing the whole drive queue (capacity
+    forced to 0) even though nothing was supposed to change. This asserts
+    the marker file stays absent and the output names what would have been
+    set instead, matching `_fire_pending_roll`'s and `_apply_cordons`'s
+    existing dry-run wording conventions."""
+    monkeypatch.setattr(
+        release_cmd, "_fetch_board",
+        lambda: ({"assignments": [{"machine_name": "server", "issue_number": 9,
+                                   "status": "RUNNING"}]}, None),
+    )
+    monkeypatch.setattr(
+        release_cmd, "_roll_python",
+        lambda *a, **k: pytest.fail("a busy daemon must roll nothing, anywhere"),
+    )
+    _stub_verify(monkeypatch, versions={"laptop": ["0.4.110"], "server": ["0.4.110"]},
+                 daemon="server")
+    result = CliRunner().invoke(
+        main,
+        ["release", "propagate", "--config", str(valid_config_path),
+         "--target", "0.4.111", "--dry-run"],
+    )
+    assert result.exit_code == 0, result.output
+    assert dq_cmd.read_roll_pending() is None, (
+        "--dry-run must never write the real #2587 roll-pending marker"
+    )
+    assert "would set a roll-pending marker" in result.output
+    assert "0.4.111" in result.output
+
+
 def test_a_second_busy_daemon_deferral_does_not_re_arm_the_marker(
     valid_config_path, state_dir, no_network, monkeypatch
 ):