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

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

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

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

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

{code_coordinator-0.5.266 → code_coordinator-0.5.268}/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.268}/coord/drive.py

@@ -587,6 +587,14 @@ class Action:
     # the work row's own last attempt reported, or `_decide_merge` would
     # diagnose one PR using the other PR's gates.
     merge_scope: str = "work"
+    # #2871: an explicit ``(event_type, summary, details)`` for `Driver._loop`
+    # to write via `_record_drive_audit`, independent of whatever this Action
+    # otherwise does (WAIT/RUN/EXIT). `decide()` stays a pure function of its
+    # inputs — it hands back *what happened*, never writes the audit log
+    # itself — while still letting a poll that neither dispatches nor exits
+    # (e.g. bypassing a stale pre-dispatch refusal) leave a durable trail
+    # instead of only a run-log line nobody queries later.
+    audit_event: tuple[str, str, dict[str, Any]] | None = None
 
     @property
     def is_exit(self) -> bool:
@@ -605,6 +613,44 @@ def _die(message: str, exit_code: int = EXIT_TERMINAL_FAILURE) -> Action:
     return Action(kind=EXIT, message=message, exit_code=exit_code)
 
 
+def _format_age(seconds: float) -> str:
+    """Coarse human age ('38m', '15h', '1.2d') for a pre-dispatch audit note.
+
+    Deliberately not the CLI's full relative-time renderer — this is one
+    field inside an audit `summary`/`details`, not a UI surface, so a small
+    self-contained formatter is enough (#2871).
+    """
+    seconds = max(0.0, seconds)
+    if seconds < 3600:
+        return f"{int(seconds // 60)}m"
+    if seconds < 86400:
+        return f"{seconds / 3600:.0f}h"
+    return f"{seconds / 86400:.1f}d"
+
+
+def _refused_policy_is_stale(state: IssueState) -> bool:
+    """True when a terminal ``refused_policy`` work row no longer describes
+    the issue as it stands now (#2871).
+
+    A worker refuses pre-dispatch work exactly once, correctly, for the ask
+    it was shown — the refusal says nothing about a DIFFERENT ask on the same
+    issue number. If the issue was retargeted (title rewritten) after that
+    row finished, the branch it would have produced (workers name branches
+    ``issue-{N}-{slugify(title)}`` at dispatch time, see
+    ``coord.agent``'s ``branch_name`` construction) no longer matches what a
+    fresh dispatch would name — that mismatch is the signal a retarget
+    happened. Conservative on every uncertainty (no branch recorded, no
+    title resolved): returns ``False`` — i.e. still treated as blocking —
+    rather than risk waving a genuinely-unresolved refusal through.
+    """
+    if not state.work_branch or not state.issue_title:
+        return False
+    from coord.agent import _slugify  # noqa: PLC0415
+
+    expected_branch = f"issue-{state.issue}-{_slugify(state.issue_title)}"
+    return state.work_branch != expected_branch
+
+
 # ── oracle-loop JIT slice authoring (#1453) ─────────────────────────────────
 
 
@@ -2036,8 +2082,58 @@ def decide(
         # deliverable was a doc edit, which CLAUDE.md itself tells a worker
         # to refuse and stop rather than attempt). Unlike an ADVISORY 0-commit
         # exit, retrying changes nothing — the rule this worker cited is not
-        # going anywhere — so this is a `_die()` exactly like every other
-        # terminal branch here, but the message embeds
+        # going anywhere — UNLESS the issue itself has since changed.
+        #
+        # #2871: a refusal is a verdict on the ASK the worker was shown, not
+        # a standing veto on the issue NUMBER forever. `coord/claim.py`'s
+        # `find_work_claim` never even sees this row (it's terminal, so it
+        # lives in `board.completed`) — the reason a stale refusal blocks
+        # every later drive is entirely HERE: `work_aid`/`work_status` above
+        # are the latest work-like row for this issue regardless of how old
+        # or how differently-scoped it is, so a fresh `coord drive` launch
+        # reads the fossil row as "this run's" state before ever reaching
+        # `_dispatch_work_stage`. If the issue was retargeted (title
+        # rewritten) after this row finished, `_refused_policy_is_stale`
+        # detects it — the old refusal no longer describes what a fresh
+        # dispatch would even be asked to do — and this bypasses the veto
+        # instead of dying again on the SAME prose a fresh worker never
+        # produced this run (CC#916).
+        age_seconds = (
+            time.time() - state.work_finished_at
+            if state.work_finished_at is not None
+            else None
+        )
+        age = _format_age(age_seconds) if age_seconds is not None else "unknown age"
+        if _refused_policy_is_stale(state):
+            bypass_summary = (
+                f"pre-dispatch: bypassing stale refused_policy assignment "
+                f"{state.work_aid} ({age} old) on issue {state.repo}#{state.issue} "
+                f"— retargeted since (branch {state.work_branch!r} no longer "
+                "matches the issue's current title); dispatching fresh work (#2871)"
+            )
+            dispatch = _dispatch_work_stage(
+                state, opts, counters, machine, oracle, gate_checker, verifier
+            )
+            return replace(
+                dispatch,
+                audit_event=(
+                    "refused_policy_stale",
+                    bypass_summary,
+                    {
+                        "stale_assignment_id": state.work_aid,
+                        "stale_branch": state.work_branch,
+                        "age_seconds": age_seconds,
+                    },
+                ),
+            )
+        # Still genuinely blocking: `_die()` exactly like every other
+        # terminal branch here, but the message now says explicitly that
+        # THIS run refused pre-dispatch on an OLD row (naming it and its
+        # age) rather than reading as a fresh worker refusing again — and
+        # names the remedy that actually clears it (#2871: retargeting is
+        # what makes the branch above fire on the next drive; `coord
+        # drive-queue remove`+`add` alone does nothing, since the queue row
+        # was never what was blocking). The message still embeds
         # `POLICY_REFUSAL_MARKER`: `coord/drive_queue.py`'s
         # `_reconcile_running` recognises that marker in this run's own
         # `drive_exited` audit summary and parks the queue entry
@@ -2046,12 +2142,16 @@ def decide(
         # principle #1844 already applies pre-dispatch, applied here
         # post-dispatch.
         return _die(
-            f"work {state.work_aid} refused on a standing repo-rule "
-            "prohibition rather than doing the dispatched work — the worker "
-            "did the CORRECT thing (#2234). Needs the coordinator: do the "
-            "work directly (or re-scope the issue so its deliverable isn't "
-            f"coordinator-only), then `coord drive-queue remove {state.repo} "
-            f"{state.issue}` once handled.\n"
+            f"pre-dispatch refusal on assignment {state.work_aid} "
+            f"(refused_policy, {age} old) — work refused on a standing "
+            "repo-rule prohibition rather than doing the dispatched work; "
+            "the worker did the CORRECT thing (#2234). Needs the "
+            "coordinator: do the work directly, OR retarget the issue "
+            "(rewrite its title so the deliverable matches what should "
+            "actually be dispatched) — the next `coord drive` detects the "
+            "retarget and dispatches fresh work automatically (#2871), so "
+            f"`coord drive-queue remove {state.repo} {state.issue}` + `add` "
+            "then genuinely clears this once the issue is retargeted.\n"
             f"   inspect: coord log {state.work_aid} --machine "
             f"{state.work_machine or machine}\n"
             f"   {POLICY_REFUSAL_MARKER}"
@@ -4680,6 +4780,15 @@ class Driver:
             for warning in action.warnings:
                 self.warn(warning)
 
+            # #2871: `decide()` stays a pure function of its inputs — it
+            # cannot write the audit log itself — so an Action that carries
+            # its own audit note (e.g. bypassing a stale pre-dispatch
+            # refusal) gets recorded here, the one place this loop already
+            # writes durable `drive_*` audit rows.
+            if action.audit_event is not None:
+                event_type, summary, details = action.audit_event
+                self._record_drive_audit(event_type, summary, details=details)
+
             # #2443: self-heal — see `_self_heal_drift_message`. Tracked off
             # the Action's own `label`, NOT `fingerprint` above: a WAIT can
             # (and, in the #2286 shape, does) repeat the identical reason

{code_coordinator-0.5.266 → code_coordinator-0.5.268}/coord/drive_queue.py

@@ -3107,18 +3107,32 @@ def _reconcile_running(
     # _decide` marks a `refused_policy` work row with `POLICY_REFUSAL_
     # MARKER` (coord.models) rather than `EXIT_DISPATCH_REFUSED`, so this is
     # checked purely off `own_reason` text, independent of `exit_refused`.
-    # Unlike #2063 this NEVER self-clears — a policy refusal names a
-    # STANDING rule, not a pending verdict — so it deliberately does not get
-    # the "queue resumes it automatically" wording Gate-A's park does; see
-    # `plan_tick`'s pre-pass below, which recognises this same marker and
-    # leaves the entry parked rather than falling through to the CI-park
-    # auto-resume. An operator clears it exactly like a `blocked` entry:
-    # handle it, then `coord drive-queue remove`.
+    # Unlike #2063 this does not self-clear on its own timer — a policy
+    # refusal names a STANDING rule, not a pending verdict — so it
+    # deliberately does not get the "queue resumes it automatically" wording
+    # Gate-A's park does; see `plan_tick`'s pre-pass below, which recognises
+    # this same marker and leaves the entry parked rather than falling
+    # through to the CI-park auto-resume.
+    #
+    # #2871: the precondition IS an operator action, but it is a RETARGET
+    # (rewrite the issue so its deliverable isn't the coordinator-only thing
+    # that got refused), not queue surgery. Before #2871, `coord.drive.
+    # decide()` re-read the SAME stale `refused_policy` row on every relaunch
+    # regardless of what the issue said by then, so `remove`+`add` looked
+    # like the fix but did nothing — a fresh queue row, same blocking
+    # assignment. `decide()` now compares that row's branch against the
+    # issue's CURRENT title-derived slug (`_refused_policy_is_stale`) and
+    # bypasses a stale refusal instead of dying on it again, so `remove`+
+    # `add` (or any later relaunch) genuinely works — but only once the
+    # retarget has actually happened.
     if own_reason and is_policy_refusal_reason(own_reason):
         reason = (
             f"{own_reason} — parking without spending an attempt (#2234); "
-            "needs the coordinator, not a relaunch — `coord drive-queue "
-            "remove` once handled"
+            "needs the coordinator, not a relaunch — retarget the issue "
+            "(rewrite its title so the deliverable isn't coordinator-only), "
+            "then `coord drive-queue remove`+`add` (or just relaunch "
+            "`coord drive`) — it now detects the retarget and dispatches "
+            "fresh work automatically (#2871)"
         )
         return (
             Reconcile(

{code_coordinator-0.5.266 → code_coordinator-0.5.268}/coord/drive_state.py

@@ -111,6 +111,13 @@ class IssueState:
     work_acceptance_state: str = ""
     work_acceptance_reason: str = ""
     work_acceptance_sha: str = ""
+    # #2871: when the work row went terminal — ``None`` for a row still
+    # running/pending or predating this column. Paired with `issue_title`
+    # below so `decide()` can tell a genuinely-still-blocking
+    # `refused_policy` row apart from one whose issue was retargeted
+    # (title rewritten) after it finished, and can name the row's age in
+    # whatever it reports instead of silently re-quoting stale prose.
+    work_finished_at: float | None = None
 
     review_aid: str = ""
     review_status: str = ""
@@ -181,6 +188,13 @@ class IssueState:
     # `oracle:exempt`/`manifest.exempt` opt-out for the trust gate
     # (`AcceptanceGateChecker.is_issue_exempt`) without a second board scan.
     issue_labels: tuple[str, ...] = ()
+    # #2871: this issue's CURRENT GitHub title — resolved from the same
+    # `/board` `issues` row `issue_labels` is, no extra I/O. Compared
+    # against a terminal `refused_policy` work row's branch (workers name
+    # branches `issue-{N}-{slugify(title)}` at dispatch time) to detect a
+    # retarget: an issue whose deliverable was rewritten after the worker
+    # refused no longer matches the branch that refusal was about.
+    issue_title: str = ""
 
     # The JIT slice's own `type="test-author"` assignment (#1171: keyed on
     # `for_issue_number == issue`, NOT `issue_number` — that field is the
@@ -355,6 +369,13 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         return default if value is None else value
 
     exit_code = (work or {}).get("exit_code")
+    finished_at_raw = (work or {}).get("finished_at")
+    try:
+        work_finished_at = (
+            float(finished_at_raw) if finished_at_raw is not None else None
+        )
+    except (TypeError, ValueError):
+        work_finished_at = None
 
     # #1453: oracle-loop JIT slice resolution — both reads are over data
     # already published on /board, no extra I/O (see IssueState's docstring
@@ -368,10 +389,12 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
     # instead of discovering a mismatch only when #1711's dispatch-time
     # guard refuses it. No extra I/O: `issues` is already part of *payload*.
     issue_labels: list[str] = []
+    issue_title = ""
     for oi in payload.get("issues") or []:
         if oi.get("repo_name") == repo and oi.get("number") == issue:
             milestone_number = oi.get("milestone_number")
             issue_labels = list(oi.get("labels") or [])
+            issue_title = oi.get("title") or ""
             break
 
     milestone_tracking_issue = None
@@ -451,6 +474,7 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         work_acceptance_state=g(work, "acceptance_state"),
         work_acceptance_reason=g(work, "acceptance_reason"),
         work_acceptance_sha=g(work, "acceptance_sha"),
+        work_finished_at=work_finished_at,
         review_aid=g(review, "assignment_id"),
         review_status=g(review, "status"),
         review_verdict=g(review, "review_verdict"),
@@ -472,6 +496,7 @@ def project(payload: dict, repo: str, issue: int, config: Any) -> IssueState:
         milestone_number=milestone_number,
         milestone_tracking_issue=milestone_tracking_issue,
         issue_labels=tuple(issue_labels),
+        issue_title=issue_title,
         # #2024: the per-issue Test-stage policy, off the labels already read
         # above (no extra I/O). `test_mode_from_labels` is the same function
         # `coord.state._get_issue_test_mode_local` uses, so the driver and the

{code_coordinator-0.5.266 → code_coordinator-0.5.268}/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.268}/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.268}/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(