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

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

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

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

{code_coordinator-0.5.266 → 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.266 → 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.266 → 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.266 → 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.266 → 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.266 → code_coordinator-0.5.267}/tui/src/app/data.rs

@@ -2689,27 +2689,42 @@ pub(crate) fn spawn_issue_detail_fetch(
 ) -> std::sync::mpsc::Receiver<Option<String>> {
     let (tx, rx) = std::sync::mpsc::channel();
     std::thread::spawn(move || {
-        let agent = ureq::AgentBuilder::new()
-            .timeout_connect(std::time::Duration::from_secs(3))
-            .timeout(std::time::Duration::from_secs(5))
-            .build();
-        let mut req = agent.get(&format!("{base_url}/issue/{repo_name}/{number}"));
-        if let Some(t) = token {
-            req = req.set("Authorization", &format!("Bearer {t}"));
-        }
-        let out = match req.call() {
-            Ok(resp) => resp
-                .into_string()
-                .ok()
-                .and_then(|body| serde_json::from_str::<serde_json::Value>(&body).ok())
-                .and_then(|v| v.get("body").and_then(|f| f.as_str()).map(|s| s.to_string())),
-            Err(_) => None,
-        };
+        let out = fetch_issue_body_blocking(&base_url, token.as_deref(), &repo_name, number);
         let _ = tx.send(out);
     });
     rx
 }
 
+/// #1939: the synchronous core of [`spawn_issue_detail_fetch`], factored out
+/// so a one-shot caller that isn't on the render-tick poll loop (e.g.
+/// [`super::sessions::CoordApp::chat_briefing`]'s Chat-session briefing) can
+/// block on the same `GET /issue/{repo}/{number}` request inline instead of
+/// arming a receiver nothing will ever drain. `None` on any HTTP/parse
+/// failure, same as the async path.
+pub(crate) fn fetch_issue_body_blocking(
+    base_url: &str,
+    token: Option<&str>,
+    repo_name: &str,
+    number: u64,
+) -> Option<String> {
+    let agent = ureq::AgentBuilder::new()
+        .timeout_connect(std::time::Duration::from_secs(3))
+        .timeout(std::time::Duration::from_secs(5))
+        .build();
+    let mut req = agent.get(&format!("{base_url}/issue/{repo_name}/{number}"));
+    if let Some(t) = token {
+        req = req.set("Authorization", &format!("Bearer {t}"));
+    }
+    match req.call() {
+        Ok(resp) => resp
+            .into_string()
+            .ok()
+            .and_then(|body| serde_json::from_str::<serde_json::Value>(&body).ok())
+            .and_then(|v| v.get("body").and_then(|f| f.as_str()).map(|s| s.to_string())),
+        Err(_) => None,
+    }
+}
+
 /// #584: fetch the read-only board projection from the `coord serve` daemon
 /// over HTTP and assemble it into a [`BoardData`] via the shared
 /// [`assemble_board_data`] tail (so the machine probes still run exactly as the

{code_coordinator-0.5.266 → code_coordinator-0.5.267}/tui/src/app/drive_queue.rs

@@ -1626,15 +1626,23 @@ impl CoordApp {
     /// layered lookup as `board_issue_body_list` (`render.rs:1754`) — this
     /// exists so a fetch stays a last resort, not the common path:
     ///
-    /// 1. Synced row in `data.open_issues` — fast path, no I/O. `/board`
-    ///    ships the full `issues` table, so this is the overwhelming case.
-    /// 2. In-memory `fetched_issues_cache`, populated by a prior background
+    /// 1. Synced row in `data.open_issues` — fast path, no I/O. **#1939:**
+    ///    `/board` now truncates an open (non-epic) issue's body to its
+    ///    machine-parsed residue, same as it has long done for closed
+    ///    issues, so this step now mirrors `board_issue_body_list`'s
+    ///    `body_truncated` check instead of assuming the synced row always
+    ///    carries the full text.
+    /// 2. `issue_detail_cache`, hydrated by the `GET /issue/{repo}/{number}`
+    ///    background fetch `issue_body_fetch_target` arms for this tab too
+    ///    (#1939) — consulted only when step 1's row is `body_truncated`.
+    /// 3. In-memory `fetched_issues_cache`, populated by a prior background
     ///    `gh issue view` for this session (shared with Board/Pipeline — one
-    ///    fetch of an issue serves every panel that shows it).
-    /// 3. An in-flight background fetch — show a "Fetching…" placeholder and
+    ///    fetch of an issue serves every panel that shows it). Only reached
+    ///    when the issue has no synced row at all.
+    /// 4. An in-flight background fetch — show a "Fetching…" placeholder and
     ///    let the next render pick up the result.
-    /// 4. No data yet — spawn `gh issue view` in the background (at most
-    ///    once per issue: step 3's in-flight check makes every subsequent
+    /// 5. No data yet — spawn `gh issue view` in the background (at most
+    ///    once per issue: step 4's in-flight check makes every subsequent
     ///    frame a no-op fetch-wise until it resolves) and show a placeholder.
     pub(crate) fn queue_issue_body_list(&self) -> ListView {
         // #1867: use the pane width stashed at draw time for word-wrapping.
@@ -1673,8 +1681,26 @@ impl CoordApp {
             .iter()
             .find(|oi| oi.repo_name == repo && oi.number == number)
         {
+            // #1939: the /board wire now truncates an open (non-epic)
+            // issue's body too (previously only closed ones) — mirror
+            // `board_issue_body_list`'s hydration check so this pane
+            // doesn't regress to showing the truncation notice forever.
+            // `issue_body_fetch_target` arms the same
+            // GET /issue/{repo}/{number} fetch for the Queue tab.
+            let hydrated: Option<&str> = if oi.body_truncated {
+                self.issue_detail_cache
+                    .get(&key)
+                    .and_then(|e| e.full.as_deref())
+            } else {
+                None
+            };
             return issue_body_list(
-                Some((oi.number, oi.title.as_str(), oi.body.as_str(), &oi.labels[..])),
+                Some((
+                    oi.number,
+                    oi.title.as_str(),
+                    hydrated.unwrap_or(oi.body.as_str()),
+                    &oi.labels[..],
+                )),
                 self.queue_detail_scroll,
                 "queue-issue-body",
                 wrap_width,