code-coordinator 0.5.197__tar.gz → 0.5.200__tar.gz

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.197",
+  "tag": "0.5.200",
   "distance": 0,
-  "node": "gac6cd7be56630a9693710286586d56b6c59bc767",
+  "node": "gc8878ff7b1ebea74a3711aba656f4ccbb265122e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/coord/pipeline.py

@@ -228,6 +228,17 @@ def compute_pipeline(
         None,
     )
 
+    # #2498: a review that came back "request-changes" must never read as
+    # mergeable, no matter what else is true about the assignment (including
+    # a stray `mq_entry` — see the `mq_entry is not None` branch below, and
+    # the unconditional "enqueue" gate this used to feed). Computed once here
+    # so both the stage-progression chain and the stage-status/gate-list
+    # logic further down share the same verdict check.
+    review_rejected = (
+        review_assignment is not None
+        and review_assignment.review_verdict == "request-changes"
+    )
+
     # ── Determine current_stage ──────────────────────────────────────────────
     current_stage: str
     if assignment.status == "running":
@@ -251,7 +262,39 @@ def compute_pipeline(
         current_stage = "merged"
     elif assignment.status in ("done", "pending"):
         # Evaluate from most advanced to least advanced.
-        if mq_entry is not None:
+        # #2498: an `mq_entry` (queued/merging/merged) no longer trumps
+        # everything else when the linked review came back request-changes —
+        # fall through to the normal review/smoke evaluation below instead,
+        # so a rejected review keeps showing as blocked even if it was
+        # (incorrectly) enqueued before this fix, or by any other path that
+        # doesn't re-check the verdict.
+        #
+        # #2498 (review 1): a *genuine* smoke/test failure or an
+        # in-progress smoke assignment must still be checked, and still win,
+        # BEFORE `review_assignment` — those are real, distinct signals
+        # (an infra failure, or a smoke run that hasn't finished yet) and
+        # existing coverage (test_failed_smoke_assignment_does_not_fall_
+        # through_to_review) depends on a failed smoke assignment surfacing
+        # even when a review also completed.
+        #
+        # But `assignment.smoke_test == "pass"` (and the sibling
+        # "smoke_assignment done → treat as passed" branch) is a different
+        # kind of signal: per `coord/state.py:_record_test_verdict_local`
+        # (#1384), recording `test_state="passed"` always mirrors to
+        # `smoke_test="pass"` on this same work assignment — the default
+        # behaviour on every ordinary Test-gate pass, not an edge case — and
+        # `auto_loop.py`'s `test_precedes_review` gate requires exactly that
+        # mirrored "passed" state before it will ever dispatch a review. So
+        # by the time `review_assignment` exists at all, `smoke_test` is
+        # already "pass" essentially every time — meaning checking it before
+        # `review_assignment` resolved `current_stage` to "smoke_passed" and
+        # never reached the review branch at all, leaving `review_rejected`
+        # unenforced on the realistic "Test passed, then Review rejected"
+        # path. A dispatched review is definitionally more advanced than a
+        # merely-passed Test gate (Test precedes Review), so the "pass"
+        # branches move below the review check while the failure/running
+        # branches stay above it.
+        if mq_entry is not None and not review_rejected:
             from coord.merge_queue import MERGED, MERGING
 
             if mq_entry.state == MERGED:
@@ -260,8 +303,6 @@ def compute_pipeline(
                 current_stage = "merging"
             else:
                 current_stage = "merge_ready"
-        elif assignment.smoke_test == "pass":
-            current_stage = "smoke_passed"
         elif assignment.smoke_test == "fail":
             current_stage = "smoke_failed"
         elif smoke_assignment is not None and smoke_assignment.status in ("running", "pending"):
@@ -270,9 +311,6 @@ def compute_pipeline(
             # Smoke assignment itself failed (infra failure) — not the same as
             # the smoke *test* failing, but still unblocks the work assignment.
             current_stage = "smoke_failed"
-        elif smoke_assignment is not None and smoke_assignment.status in ("done",):
-            # Smoke assignment completed but smoke_test not yet set — treat as passed.
-            current_stage = "smoke_passed"
         elif review_assignment is not None:
             if review_assignment.status in ("running", "pending", "finalizing"):
                 # #1566: "finalizing" is a review row whose agent finished but
@@ -288,6 +326,11 @@ def compute_pipeline(
                 current_stage = "review_failed"
             else:
                 current_stage = "review_done"
+        elif assignment.smoke_test == "pass":
+            current_stage = "smoke_passed"
+        elif smoke_assignment is not None and smoke_assignment.status in ("done",):
+            # Smoke assignment completed but smoke_test not yet set — treat as passed.
+            current_stage = "smoke_passed"
         else:
             current_stage = "done"
     else:
@@ -327,6 +370,12 @@ def compute_pipeline(
             # This is the current stage.
             if current_stage == "merged":
                 status = "completed"  # final state, show as completed
+            elif current_stage == "review_done" and review_rejected:
+                # #2498: the review step finished, but a request-changes
+                # verdict means it did NOT clear the assignment for the next
+                # gate — show "active"/blocked, not a green "completed" that
+                # reads as "review passed."
+                status = "active"
             elif current_stage in ("smoke_passed", "review_done"):
                 status = "completed"  # sub-stage "done", ready for next gate
             elif current_stage == "failed":
@@ -367,7 +416,13 @@ def compute_pipeline(
     elif current_stage == "review_failed":
         available_gates.append(PipelineGate("dispatch_review", "Dispatch Review", _EP))
     elif current_stage == "review_done":
-        available_gates.append(PipelineGate("enqueue", "Queue for Merge", _EP))
+        # #2498: only offer "Queue for Merge" when the review is approved or
+        # hasn't produced a verdict yet — a request-changes verdict must not
+        # be one click from the merge queue. `dispatch_fix` just below is
+        # already correctly gated the mirror-image way (only offered ON
+        # request-changes); this makes `enqueue` its proper complement.
+        if not review_rejected:
+            available_gates.append(PipelineGate("enqueue", "Queue for Merge", _EP))
         if review_assignment is not None and review_assignment.review_posted_at is None:
             available_gates.append(PipelineGate("post_findings", "Post Findings", _EP))
         # Offer the phone a way to record a review verdict manually when the

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tests/test_pipeline.py

@@ -1787,3 +1787,99 @@ class TestDispatchFixGateForRequestChanges:
         pv = compute_pipeline(work, board, [], _config())
         gate_actions = {g.action for g in pv.available_gates}
         assert "dispatch_fix" not in gate_actions
+
+
+class TestMergeQueueIgnoresRejectedReview:
+    """#2498: coord-web showed a request-changes review as mergeable once
+    merge-queued — the top badge read "mergeable," the Review row in the
+    gate-status list read green/"completed," and "Merge" was enabled,
+    directly under a Review section whose own verdict said "Changes
+    requested." Root cause was `current_stage`'s `mq_entry is not None`
+    check firing unconditionally, before ever consulting
+    `review_assignment.review_verdict` — and a second bug feeding it: the
+    "enqueue" gate at review_done was offered unconditionally instead of
+    being gated on the verdict the way `dispatch_fix` already was."""
+
+    def test_mq_entry_with_rejected_review_is_not_merge_ready(self) -> None:
+        """An mq_entry existing (e.g. from before this fix, or any other path
+        that skipped the verdict check) must not make a request-changes
+        assignment read as merge_ready/merging/merged."""
+        work = _work(aid="work-1", status="done")
+        rev = _review(of_aid="work-1", status="done")
+        rev.review_verdict = "request-changes"
+        mq = [_mq_entry(state=PENDING)]
+        board = Board(completed=[work, rev])
+        pv = compute_pipeline(work, board, mq, _config())
+
+        assert pv.current_stage not in ("merge_ready", "merging", "merged")
+        assert pv.current_stage == "review_done"
+
+        gate_actions = {g.action for g in pv.available_gates}
+        assert "merge" not in gate_actions
+        assert "enqueue" not in gate_actions
+        assert "dispatch_fix" in gate_actions
+
+        review = next(s for s in pv.stages if s.name == "review")
+        assert review.status != "completed"
+
+    def test_review_done_rejected_does_not_offer_enqueue(self) -> None:
+        """Even with no mq_entry at all, "Queue for Merge" must not be
+        offered on a request-changes verdict (the bug's proximate cause: a
+        human — or an automated caller — one click from queueing rejected
+        code)."""
+        work = _work(aid="work-1", status="done")
+        rev = _review(of_aid="work-1", status="done")
+        rev.review_verdict = "request-changes"
+        board = Board(completed=[work, rev])
+        pv = compute_pipeline(work, board, [], _config())
+
+        assert pv.current_stage == "review_done"
+        gate_actions = {g.action for g in pv.available_gates}
+        assert "enqueue" not in gate_actions
+        assert "dispatch_fix" in gate_actions
+
+    def test_smoke_test_pass_then_rejected_review_is_not_smoke_passed(self) -> None:
+        """#2498 review 1: the realistic path. Per `_record_test_verdict_local`
+        (#1384), a passed Test gate always mirrors `smoke_test="pass"` onto
+        the parent work assignment BEFORE review ever dispatches (Test
+        precedes Review) — so `smoke_test == "pass"` is the normal state by
+        the time a review completes, not an edge case. The old elif-chain
+        checked `assignment.smoke_test == "pass"` before `review_assignment
+        is not None`, so it resolved to "smoke_passed" and never reached the
+        review_rejected guard at all: the review stage rendered "waiting"
+        (hiding that a review even ran) and the untouched `smoke_passed`
+        branch offered "enqueue" unconditionally — one click from queueing
+        rejected code. No `mq_entry` needed to trigger it."""
+        work = _work(aid="work-1", status="done", smoke_test="pass")
+        rev = _review(of_aid="work-1", status="done")
+        rev.review_verdict = "request-changes"
+        board = Board(completed=[work, rev])
+        pv = compute_pipeline(work, board, [], _config())
+
+        assert pv.current_stage not in ("smoke_passed", "merge_ready", "merging", "merged")
+        assert pv.current_stage == "review_done"
+
+        gate_actions = {g.action for g in pv.available_gates}
+        assert "enqueue" not in gate_actions
+        assert "dispatch_fix" in gate_actions
+
+        review = next(s for s in pv.stages if s.name == "review")
+        assert review.status != "waiting"
+        assert review.status != "completed"
+
+    def test_review_done_approved_still_offers_enqueue_with_mq_entry_absent(self) -> None:
+        """Sanity check the fix doesn't over-correct: an approved (or
+        no-verdict-yet) review_done still offers enqueue, unaffected."""
+        work = _work(aid="work-1", status="done")
+        rev = _review(of_aid="work-1", status="done")
+        rev.review_verdict = "approve"
+        board = Board(completed=[work, rev])
+        pv = compute_pipeline(work, board, [], _config())
+
+        assert pv.current_stage == "review_done"
+        gate_actions = {g.action for g in pv.available_gates}
+        assert "enqueue" in gate_actions
+        assert "dispatch_fix" not in gate_actions
+
+        review = next(s for s in pv.stages if s.name == "review")
+        assert review.status == "completed"

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/data.rs

@@ -274,6 +274,17 @@ pub(crate) struct FindingsDetailEntry {
     pub(crate) full: Option<String>,
 }
 
+/// #2497: one hydrated (or failed) full-issue-body detail fetch — see
+/// `CoordApp::issue_detail_cache`. Mirrors [`FindingsDetailEntry`] (#1337)
+/// for `issues.body` instead of `assignments.review_findings`.
+pub(crate) struct IssueDetailEntry {
+    pub(crate) fetched_at: Instant,
+    /// `Some(body)` = the full issue body from `GET /issue/{repo}/{number}`.
+    /// `None` = the fetch failed; re-armed after a 30 s back-off so a down
+    /// daemon isn't hammered every tick.
+    pub(crate) full: Option<String>,
+}
+
 /// #336: Sanitize a git branch name for use as a URL path component.
 ///
 /// Mirrors Python's `coord.agent._sanitize_branch`: replaces runs of
@@ -1573,6 +1584,8 @@ pub(crate) fn load_data() -> BoardData {
                             .unwrap_or_else(|_| "open".to_string()),
                         milestone_number: row.get::<_, Option<i64>>(6).unwrap_or(None),
                         milestone_title: row.get::<_, Option<String>>(7).unwrap_or(None),
+                        body_truncated: false,
+                        body_len: None,
                     })
                 })
                 .map(|rows| rows.filter_map(|r| r.ok()).collect())
@@ -2410,6 +2423,42 @@ pub(crate) fn spawn_findings_detail_fetch(
     rx
 }
 
+/// #2497: fetch one issue's FULL `body` from the daemon's single-issue
+/// detail endpoint (`GET /issue/{repo_name}/{number}`). The `/board`
+/// collection wire drops a closed (non-epic) issue's body to 0 chars
+/// (`board_wire.bound_issue_row`, #1791); the Board/Pipeline Issue tab
+/// hydrates the full body through this. Mirrors
+/// [`spawn_findings_detail_fetch`] (#1337). Sends `None` on any HTTP/parse
+/// failure (the pane keeps showing the truncation notice).
+pub(crate) fn spawn_issue_detail_fetch(
+    base_url: String,
+    token: Option<String>,
+    repo_name: String,
+    number: u64,
+) -> 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 _ = tx.send(out);
+    });
+    rx
+}
+
 /// #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.197 → code_coordinator-0.5.200}/tui/src/app/dialogs.rs

@@ -84,6 +84,29 @@ impl CoordApp {
                 "send-to-pipeline",
                 "Send to Pipeline",
             ));
+            // #2494: "Add to drive queue" — `coord drive-queue add <repo>
+            // <issue>`, this repo's own recommended dispatch path
+            // (docs/DRIVE_QUEUE.md) and a genuinely different mechanism from
+            // "Send to Pipeline" above (`coord track`, the label-based `coord
+            // plan`/`approve` flow, with no drive-queue equivalent). Reuses
+            // the exact same menu-item/dispatch machinery the Pipeline row's
+            // `PipelineRowLifecycle::New` block already offers below —
+            // `pipeline_menu_repo_issue` (the shared dispatch-side resolver
+            // behind the `"drive-queue-add"`/`"drive-queue-row-remove"`/
+            // `"drive-queue-add-on:<machine>"` action ids) already treats
+            // `BoardRow` and `PipelineRow` targets identically, so no new
+            // action ids or dispatch plumbing are needed here — only this
+            // menu-content wiring. `offer_add: true` (queue-or-update, safe
+            // to invoke more than once) gated on the same Backlog-only
+            // lifecycle as "Send to Pipeline": queuing something already
+            // in-flight doesn't make sense. Swaps to "Remove from drive
+            // queue" for a row somehow already queued (e.g. added via `coord
+            // drive-queue add` directly before ever visiting the TUI).
+            items.extend(self.drive_queue_menu_items_for_pipeline_row(
+                issue_number,
+                repo_name,
+                true,
+            ));
             items.push(ContextMenuItem::separator());
         }
         // #661: the Board has NO direct dispatch. Choosing HOW to run an issue
@@ -1289,12 +1312,27 @@ impl CoordApp {
                 tracking_issue,
                 milestone_title,
                 milestone_number,
-            } => self.context_menu_items_for_milestone_header(
-                repo_name,
-                *tracking_issue,
-                milestone_title,
-                *milestone_number,
-            ),
+            } => {
+                // #2494: look up the epic tracking issue's own labels from
+                // the cached open-issues list so the menu can gate "Send to
+                // Pipeline" on whether it's already `coord`-labeled. No
+                // cache row (e.g. a stale/offline board) → empty labels,
+                // which offers the item — worst case a harmless re-`track`.
+                let labels: &[String] = self
+                    .data
+                    .open_issues
+                    .iter()
+                    .find(|oi| oi.repo_name == *repo_name && oi.number == *tracking_issue)
+                    .map(|oi| oi.labels.as_slice())
+                    .unwrap_or(&[]);
+                self.context_menu_items_for_milestone_header(
+                    repo_name,
+                    *tracking_issue,
+                    milestone_title,
+                    *milestone_number,
+                    labels,
+                )
+            }
             ContextMenuTarget::TerminalRow { .. } => self.context_menu_items_for_terminal_row(),
             ContextMenuTarget::PlansStub { repo_name, milestone } => {
                 self.context_menu_items_for_plans_stub(repo_name.as_deref(), milestone.as_ref())
@@ -6091,6 +6129,16 @@ impl CoordApp {
                 repo_name: Some(repo),
                 ..
             } => (repo.clone(), *num),
+            // #2494: the Plans-panel epic-row menu's "Send to Pipeline"
+            // reuses this same entry point (`coord track <repo>
+            // <tracking_issue>` is identical to the Board row's `track`
+            // call — the epic's own issue number just arrives via a
+            // different target shape).
+            ContextMenuTarget::MilestoneHeader {
+                repo_name,
+                tracking_issue,
+                ..
+            } => (repo_name.clone(), *tracking_issue),
             _ => {
                 self.push_toast(
                     &format!("{} unavailable", toast_title),

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/doc_tabs.rs

@@ -2547,6 +2547,8 @@ mod tests {
                 state: "open".to_string(),
                 milestone_number: None,
                 milestone_title: None,
+                body_truncated: false,
+                body_len: None,
             }],
             ..BoardData::default()
         };
@@ -2574,6 +2576,8 @@ mod tests {
                     state: "open".to_string(),
                     milestone_number: None,
                     milestone_title: None,
+                    body_truncated: false,
+                    body_len: None,
                 })
                 .collect(),
             pipeline_repos: vec![(
@@ -2625,6 +2629,8 @@ mod tests {
                 state: "open".to_string(),
                 milestone_number: None,
                 milestone_title: None,
+                body_truncated: false,
+                body_len: None,
             }],
             pipeline_repos: vec![(
                 "claude-coordinator".to_string(),

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/drive.rs

@@ -466,6 +466,8 @@ mod tests {
             matched_labels: vec!["coord".to_string()],
             all_labels: vec!["coord".to_string()],
             is_closed: false,
+            body_truncated: false,
+            body_len: None,
         }
     }
 

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/drive_queue.rs

@@ -2104,6 +2104,8 @@ mod tests {
             matched_labels: vec!["coord".to_string()],
             all_labels: vec!["coord".to_string()],
             is_closed: false,
+            body_truncated: false,
+            body_len: None,
         }
     }
 

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/escalation.rs

@@ -321,6 +321,8 @@ mod tests {
             matched_labels: vec!["coord".to_string()],
             all_labels: vec!["coord".to_string()],
             is_closed: false,
+            body_truncated: false,
+            body_len: None,
         }
     }
 

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/fixtures.rs

@@ -218,6 +218,8 @@ pub fn make_test_app(data: BoardData) -> CoordApp {
         artifact_fetch_rx: None,
         findings_detail_cache: std::collections::HashMap::new(),
         findings_fetch_rx: None,
+        issue_detail_cache: std::collections::HashMap::new(),
+        issue_fetch_rx: None,
         pending_artifact_pull: None,
         last_artifact_pulls: std::collections::HashMap::new(),
         artifact_pull_dialog: None,
@@ -910,6 +912,8 @@ pub fn make_app_with_one_completed_issue() -> CoordApp {
         labels: Vec::new(),
         milestone_number: None,
         milestone_title: None,
+        body_truncated: false,
+        body_len: None,
     });
     app.rebuild_board_sidebar();
     app

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/milestone_dag.rs

@@ -296,6 +296,22 @@ pub(crate) fn labels_carry_epic_label(labels: &[String]) -> bool {
         .any(|l| l.eq_ignore_ascii_case(TRACKING_ISSUE_LABEL))
 }
 
+/// Mirrors `coord.commands.issues.track`'s `"coord"` label — the label that
+/// marks an issue as Pipeline-tracked (`coord/dispatch.py`'s
+/// `label_change_for_subcommand("track")` adds it, `board_row_lifecycle`
+/// reads it back).
+pub(crate) const COORD_LABEL: &str = "coord";
+
+/// Case-insensitive check for [`COORD_LABEL`] against an arbitrary label
+/// list, mirroring `labels_carry_epic_label`'s convention. #2494: an epic
+/// tracking issue created via `coord milestone capture`/`chat` never carries
+/// this label until something runs `coord track` against it — used to gate
+/// the Plans-panel epic-row menu's "Send to Pipeline" item so it only
+/// appears while the epic is still untracked.
+pub(crate) fn labels_carry_coord_label(labels: &[String]) -> bool {
+    labels.iter().any(|l| l.eq_ignore_ascii_case(COORD_LABEL))
+}
+
 /// The open issue in `repo_name`/`milestone_number` carrying the `"epic"`
 /// label — the milestone's tracking issue (mirrors
 /// `coord.milestone_order.TRACKING_ISSUE_LABEL` / the #645 convention).
@@ -622,19 +638,37 @@ impl CoordApp {
     /// doesn't depend on it — only the id matters); it's accepted for
     /// symmetry with the target's fields and because a future item may need
     /// it for a disabled-state check.
+    ///
+    /// #2494: `labels` is the epic tracking issue's current GitHub labels
+    /// (looked up by the caller from `data.open_issues`) — used solely to
+    /// gate "Send to Pipeline": an epic created via `coord milestone
+    /// capture`/`chat` carries neither `coord` nor `status:ready` until
+    /// something runs `coord track` against it, and until then it never
+    /// appears in Pipeline at all, so every Gate A action stays unreachable.
+    /// Shown only while the epic is still untracked (mirrors the Board row
+    /// menu's own Backlog-only gate on the same action).
     pub(crate) fn context_menu_items_for_milestone_header(
         &self,
         _repo_name: &str,
         _tracking_issue: u64,
         _milestone_title: &str,
         _milestone_number: i64,
+        labels: &[String],
     ) -> Vec<ContextMenuItem> {
-        vec![
+        let mut items = vec![
             ContextMenuItem::action("open-milestone-chat", "Open milestone chat"),
             ContextMenuItem::action("dispatch-milestone", "Dispatch milestone").with_shortcut("d"),
             ContextMenuItem::action("dispatch-milestone-next", "Dispatch next…"),
             ContextMenuItem::action("view-milestone-order", "View order / DAG"),
-            ContextMenuItem::separator(),
+        ];
+        if !labels_carry_coord_label(labels) {
+            items.push(ContextMenuItem::action(
+                "send-to-pipeline",
+                "Send to Pipeline",
+            ));
+        }
+        items.push(ContextMenuItem::separator());
+        items.extend([
             ContextMenuItem::action("edit-milestone", "Edit milestone…"),
             ContextMenuItem::action("add-issue-to-milestone", "Add issue to milestone…"),
             ContextMenuItem::action(
@@ -655,7 +689,8 @@ impl CoordApp {
             ContextMenuItem::action("close-plan", "Close / archive plan"),
             ContextMenuItem::separator(),
             ContextMenuItem::action("refresh", "Refresh").with_shortcut("r"),
-        ]
+        ]);
+        items
     }
 
     /// #1123 (contract §4b/§4c): context-menu items for a Plans-panel
@@ -1298,6 +1333,8 @@ mod pure_tests {
             state: state.to_string(),
             milestone_number: None,
             milestone_title: None,
+            body_truncated: false,
+            body_len: None,
         }
     }
 

{code_coordinator-0.5.197 → code_coordinator-0.5.200}/tui/src/app/mod.rs

@@ -2905,6 +2905,19 @@ pub struct CoordApp {
         (String, i64),
         std::sync::mpsc::Receiver<Option<String>>,
     )>,
+    /// #2497: Full issue bodies hydrated from the daemon's
+    /// `GET /issue/{repo}/{number}` detail endpoint, keyed by `(repo,
+    /// issue_number)` — the /board collection wire drops a closed
+    /// (non-epic) issue's body to 0 chars (`board_wire.bound_issue_row`,
+    /// #1791). A successful entry never expires (a closed issue's body is
+    /// immutable in practice). A failed entry (`full: None`) backs off for
+    /// 30 s before re-arming. Mirrors `findings_detail_cache` (#1337).
+    issue_detail_cache: std::collections::HashMap<(String, u64), IssueDetailEntry>,
+    /// #2497: In-flight issue-body detail fetch.  `None` when idle.
+    issue_fetch_rx: Option<(
+        (String, u64),
+        std::sync::mpsc::Receiver<Option<String>>,
+    )>,
     /// #336: Tracks a pending `coord pull-artifact` dispatch.
     /// Contains `(work_id, repo, sanitized_branch)` so we can show the
     /// destination path in a completion dialog.
@@ -3956,6 +3969,8 @@ impl CoordApp {
             artifact_fetch_rx: None,
             findings_detail_cache: std::collections::HashMap::new(),
             findings_fetch_rx: None,
+            issue_detail_cache: std::collections::HashMap::new(),
+            issue_fetch_rx: None,
             pending_artifact_pull: None,
             last_artifact_pulls: std::collections::HashMap::new(),
             artifact_pull_dialog: None,
@@ -5392,6 +5407,8 @@ impl CoordApp {
                     matched_labels: matched,
                     all_labels: oi.labels.clone(),
                     is_closed: oi.state == "closed",
+                    body_truncated: oi.body_truncated,
+                    body_len: oi.body_len,
                 })
             })
             .collect();
@@ -5459,6 +5476,8 @@ impl CoordApp {
                     matched_labels: matched,
                     all_labels: oi.labels.clone(),
                     is_closed: oi.state == "closed",
+                    body_truncated: oi.body_truncated,
+                    body_len: oi.body_len,
                 });
                 present.insert(key);
             }