code-coordinator 0.5.165__tar.gz → 0.5.167__tar.gz

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.165",
+  "tag": "0.5.167",
   "distance": 0,
-  "node": "g5bd13e9adba9bf24c0bf6aedd8cb4bd19bb41bb1",
+  "node": "g9016461101b4920502a7937e28cfdc70410ffc2f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/coord/drive.py

@@ -890,7 +890,20 @@ def _decide_acceptance_author(
         # pass-through.
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
-        if not branch or not verifier.branch_has_commits(probe):
+        commits = verifier.branch_has_commits(probe) if branch else False
+        if commits is None:
+            # #2426: `None` means the check could not be completed (e.g. a
+            # transient `git fetch` failure) — NOT evidence the branch is
+            # empty. Wait for the next poll to retry rather than
+            # misdiagnosing a verification failure as the terminal
+            # zero-commit dead end below.
+            return _wait(
+                label=(
+                    f"ACCEPTANCE: JIT slice {aid} branch {branch!r} — could "
+                    "not verify commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
             # #2061: a commit-less ADVISORY row IS what an earlier-landed
             # slice's stale/retried author row looks like — check the
             # manifest before declaring failure.
@@ -936,7 +949,20 @@ def _decide_acceptance_author(
         # `advisory` branch's probe exactly.
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
-        if not branch or not verifier.branch_has_commits(probe):
+        commits = verifier.branch_has_commits(probe) if branch else False
+        if commits is None:
+            # #2426: same distinction as the ADVISORY branch above — a
+            # verification failure is not proof of an empty branch. This is
+            # exactly the claude-coordinator#2286 incident: a real pushed
+            # commit sat on the remote while a transient `git fetch` failure
+            # made this arm declare the branch commit-less and terminal.
+            return _wait(
+                label=(
+                    f"ACCEPTANCE: JIT slice {aid} branch {branch!r} — could "
+                    "not verify commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
             # #2061 (coord-portal#13): a re-dispatched author that lands in
             # a world where the slice is ALREADY on the default branch
             # correctly does nothing — DONE with zero commits — and that is
@@ -1221,7 +1247,7 @@ def _acceptance_message(message: str, state: IssueState) -> str:
 class MergeVerifier(Protocol):
     """The git/GitHub questions the state machine cannot answer itself."""
 
-    def branch_has_commits(self, state: IssueState) -> bool: ...
+    def branch_has_commits(self, state: IssueState) -> bool | None: ...
 
     def verify_merged(self, state: IssueState) -> bool: ...
 
@@ -1254,9 +1280,23 @@ class GitMergeVerifier:
             check=False,
         )
 
-    def branch_has_commits(self, state: IssueState) -> bool:
-        """True when *branch* exists on the remote and carries a commit the
-        default branch does not.
+    def branch_has_commits(self, state: IssueState) -> bool | None:
+        """``True``/``False`` when *branch* was actually checked against the
+        default branch; ``None`` when the check could not be completed.
+
+        ``False`` means VERIFIED empty: the fetches and the ``rev-list``
+        count all succeeded, and the count was exactly 0. ``None`` means no
+        such evidence exists — a transient ``git fetch`` failure (network
+        blip, GitHub hiccup, SSH auth glitch — see ``is_ci_unreadable_reason``
+        for the CI-side equivalent of this exact distinction), a missing
+        local checkout, or an unparsable ``rev-list`` count. Before #2426
+        every one of those collapsed into ``False``, indistinguishable from a
+        genuinely empty branch — and callers treated ``False`` as proof of a
+        TERMINAL dead end, misdiagnosing a fetch hiccup as "nothing was ever
+        authored" (claude-coordinator#2286: a real, pushed commit sat on the
+        remote while `coord drive` declared the branch commit-less and burned
+        11 retry cycles re-authoring from scratch). ``None`` must never be
+        treated as "no commits" — callers wait and let the next poll retry.
 
         Used to tell a REAL zero-commit advisory apart from the #1357 false
         positive, where the agent downgrades a good DONE over an artifact glob
@@ -1267,19 +1307,19 @@ class GitMergeVerifier:
             return False
         base = self._base(state)
         if base is None:
-            return False
+            return None
         target = state.repo_default_branch or "main"
         if self._git(base, "fetch", "--quiet", "origin", target).returncode != 0:
-            return False
+            return None
         if self._git(base, "fetch", "--quiet", "origin", branch).returncode != 0:
-            return False
+            return None
         proc = self._git(base, "rev-list", "--count", f"origin/{target}..FETCH_HEAD")
         if proc.returncode != 0:
-            return False
+            return None
         try:
             return int((proc.stdout or "0").strip() or 0) > 0
         except ValueError:
-            return False
+            return None
 
     def verify_merged(self, state: IssueState) -> bool:
         """Confirm the branch actually landed on the target.
@@ -1699,16 +1739,22 @@ def decide(
         pass
     elif state.work_status == "advisory":
         advisory = _decide_advisory(state, opts, counters, machine, verifier)
-        # #2416: `_decide_advisory` now returns a RUN action (a bounded
-        # `coord retry` dispatch) for the zero-commit case, not only an EXIT
-        # — `is_exit` alone would let a RUN action fall through to the
+        # #2416: `_decide_advisory` returns a RUN action (a bounded `coord
+        # retry` dispatch) for the zero-commit case, not only an EXIT —
+        # `is_exit` alone would let a RUN action fall through to the
         # Test/Review/Merge logic below as though the row were validated
-        # work. Only its "proceeding under --accept-advisory" branch returns
-        # WAIT (with warnings to fold in); every other branch (EXIT or RUN)
-        # is this poll's whole answer.
-        if advisory.kind != WAIT:
+        # work. #2426: it returns an explicit WAIT for the "could not verify
+        # — fetch failed" case, which must ALSO be this poll's whole answer,
+        # not folded into the fall-through below (that fall-through means
+        # "commits confirmed present, proceed as normal work", which a
+        # verification failure has not established either way). Only `None`
+        # — "proceeding under --accept-advisory", commits confirmed present
+        # — falls through, carrying its warning.
+        if advisory is not None:
             return advisory
-        warnings = advisory.warnings
+        warnings = (
+            "ADVISORY with commits present — proceeding per --accept-advisory (#1357)",
+        )
     elif state.work_status == "refused_policy":
         # #2234: the worker exited cleanly, pushed 0 commits, and its own
         # final message cited a standing repo-rule prohibition (`coord.agent.
@@ -1762,18 +1808,25 @@ def decide(
     # applies when there is nothing to test, review, or merge. A labelled
     # issue whose worker DID push commits (the label describes the common
     # case, not a hard rule) falls through unchanged — `branch_has_commits`
-    # is False only for the genuine 0-commit shape.
-    if (
-        state.work_status == "done"
-        and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels
-        and (not state.work_branch or not verifier.branch_has_commits(state))
-    ):
-        return _succeed(
-            f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
-            f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
-            "worker's final message is the deliverable and was posted to "
-            "the issue automatically — nothing to test, review, or merge."
-        )
+    # is False only for the genuine 0-commit shape; `None` (#2426 — the
+    # check could not be completed, e.g. a `git fetch` failure) is neither
+    # "done" nor "push commits", so it waits below instead of guessing.
+    if state.work_status == "done" and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels:
+        commits = verifier.branch_has_commits(state) if state.work_branch else False
+        if commits is None:
+            return _wait(
+                label=(
+                    f"ANALYSIS: {state.work_aid} — could not verify branch "
+                    "commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
+            return _succeed(
+                f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
+                f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
+                "worker's final message is the deliverable and was posted to "
+                "the issue automatically — nothing to test, review, or merge."
+            )
 
     # A 'done' row with no branch never pushed anything either.
     if not state.work_branch:
@@ -1930,7 +1983,7 @@ def _decide_advisory(
     counters: DriveCounters,
     machine: str,
     verifier: MergeVerifier,
-) -> Action:
+) -> Action | None:
     """The #448 downgrade: the agent flagged a zero-commit / stash-miss exit.
 
     #1357 makes this a FALSE POSITIVE for every Python-only headless assignment
@@ -1952,8 +2005,30 @@ def _decide_advisory(
     advisory_retries`) before finally giving up, so a row whose correct
     resolution really is "dispatch something else" still reaches a terminal
     `_die()` naming `coord retry` for a human — never an unbounded loop.
+
+    Returns ``None`` only for the "commits confirmed present, proceed under
+    --accept-advisory" case — the caller (`decide`) reads ``None`` as "fall
+    through to the normal Test/Review/Merge machinery", the same "nothing to
+    report, proceed" convention `_decide_test`/`_decide_review`/
+    `_decide_acceptance_gate` already use. Every other outcome, including the
+    #2426 "could not verify" case below, returns a real ``Action`` that IS
+    this poll's whole answer.
     """
-    if not state.work_branch or not verifier.branch_has_commits(state):
+    branch = state.work_branch
+    commits = verifier.branch_has_commits(state) if branch else False
+    if commits is None:
+        # #2426: `git fetch` failing does not mean the branch is empty — it
+        # means nothing was learned. Wait for the next poll to retry the
+        # check itself; do NOT spend an `advisory_retries` budget attempt (or
+        # worse, `_die()`) on a verification failure that says nothing about
+        # what the branch actually contains.
+        return _wait(
+            label=(
+                f"WORK: {state.work_aid} ADVISORY — could not verify branch "
+                "commits (git fetch failed), retrying"
+            )
+        )
+    if not commits:
         budget = opts.max_work_retries
         if counters.advisory_retries >= budget:
             return _die(
@@ -1992,12 +2067,9 @@ def _decide_advisory(
             "   Proceed anyway with --accept-advisory (and fix #1357 to stop "
             "needing it)."
         )
-    return Action(
-        kind=WAIT,
-        warnings=(
-            "ADVISORY with commits present — proceeding per --accept-advisory (#1357)",
-        ),
-    )
+    # Commits confirmed present, --accept-advisory set: fall through to the
+    # normal Test/Review/Merge machinery (the caller attaches the warning).
+    return None
 
 
 def _decide_acceptance_gate(

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/tests/test_drive.py

@@ -87,7 +87,7 @@ class FakeVerifier:
     def __init__(
         self,
         *,
-        has_commits: bool = True,
+        has_commits: bool | None = True,
         merged: bool = True,
         head_sha: str | None = "deadbeef" * 5,
     ) -> None:
@@ -98,7 +98,7 @@ class FakeVerifier:
         self.merged_calls = 0
         self.head_sha_calls = 0
 
-    def branch_has_commits(self, s: IssueState) -> bool:
+    def branch_has_commits(self, s: IssueState) -> bool | None:
         self.commits_calls += 1
         return self._has_commits
 
@@ -1019,6 +1019,29 @@ def test_oracle_active_advisory_with_no_commits_is_not_terminal_when_the_slice_a
     )
 
 
+def test_oracle_active_advisory_with_unverifiable_branch_waits():
+    """#2426: `branch_has_commits` returning `None` (e.g. a `git fetch`
+    failure) must NOT be treated as "no commits" — that misdiagnoses a
+    transient verification failure as the terminal "nothing was authored"
+    dead end (claude-coordinator#2286: a real, pushed commit sat on the
+    remote while this exact path declared the branch commit-less). It must
+    wait and let the next poll retry the check instead."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=None)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="advisory",
+            acceptance_author_branch="test-author-ms-65-slice-2286",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert "no commits" not in (action.message or "")
+
+
 def test_oracle_active_advisory_with_commits_requires_accept_advisory():
     """The #1357 false-positive shape — real commits, downgraded to
     advisory anyway — must not be treated as "still landing"; it needs the
@@ -1148,6 +1171,29 @@ def test_oracle_active_done_with_no_branch_is_terminal():
     assert "no commits" in action.message
 
 
+def test_oracle_active_done_with_unverifiable_branch_waits():
+    """#2426: the exact incident this issue documents — a terminal
+    `test-author` DONE row whose branch really did carry a commit
+    (claude-coordinator#2286's `test-author-ms-65-slice-2286`, commit
+    `250b4df8`), observed through a `git fetch` failure. Must wait and
+    retry, not declare DONE terminal-with-no-commits and burn a re-author
+    cycle."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=None)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="done",
+            acceptance_author_branch="test-author-ms-65-slice-2286",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert "no commits" not in (action.message or "")
+
+
 def test_oracle_active_done_with_commits_lands_the_slice():
     """#2079: a DONE slice whose branch carries commits is MERGED by this
     driver, not waited on.
@@ -1752,6 +1798,23 @@ def test_advisory_with_no_commits_retries_via_coord_retry_then_stops_at_the_cap(
     assert verifier.commits_calls == 2
 
 
+def test_advisory_with_unverifiable_branch_waits_without_spending_a_retry():
+    """#2426: a `git fetch` failure while checking the branch is not proof
+    it's empty. Must wait for the next poll rather than either spending an
+    `advisory_retries` budget attempt or (once the budget is spent) dying
+    with the terminal "no commits" message on evidence that never
+    materialized."""
+    verifier = FakeVerifier(has_commits=None)
+    counters = DriveCounters()
+    opts = DriveOptions(machine="precision", max_work_retries=1)
+    s = state(work_aid="w1", work_status="advisory", work_branch="b")
+
+    action = step(s, opts, verifier=verifier, counters=counters)
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert counters.advisory_retries == 0
+
+
 def test_advisory_with_no_commits_retry_is_unaffected_by_accept_advisory():
     """#1606: `--accept-advisory` exists to unblock the #1357 false-positive
     (real commits, downgraded status) — it must NOT adopt a genuine
@@ -1850,6 +1913,23 @@ def test_analysis_deliverable_done_with_no_commits_succeeds():
     assert "deliverable:analysis" in action.message
 
 
+def test_analysis_deliverable_done_with_unverifiable_branch_waits():
+    """#2426: a `git fetch` failure while checking an analysis-labelled
+    branch is neither "0-commit success" nor "commits pushed, fall
+    through" — it's no evidence at all. Must wait for the next poll."""
+    action = step(
+        state(
+            work_aid="w1",
+            work_status="done",
+            work_branch="issue-2132-diagnose",
+            issue_labels=("deliverable:analysis",),
+        ),
+        verifier=FakeVerifier(has_commits=None),
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+
+
 def test_analysis_deliverable_done_with_no_branch_at_all_succeeds():
     """Same as above when the reap never captured a branch name at all
     (e.g. the worktree was already gone) — `not state.work_branch` alone
@@ -4290,20 +4370,60 @@ def test_branch_has_commits_is_false_for_zero(recorded_git, tmp_path):
     assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is False
 
 
-def test_branch_has_commits_is_false_when_the_remote_branch_is_missing(
+def test_branch_has_commits_is_none_when_rev_list_fails(recorded_git, tmp_path):
+    """#2426: both fetches succeeded but `rev-list` itself failed — still no
+    completed count, so still `None`, not `False`."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("rev-list",)] = (128, "")
+    s = state(work_branch="b")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_rev_list_output_is_unparsable(
     recorded_git, tmp_path
 ):
+    """#2426: a malformed count is the same "learned nothing" shape as a
+    failed command — `None`, not `False`."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("rev-list",)] = (0, "not-a-number\n")
+    s = state(work_branch="b")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_a_fetch_fails(recorded_git, tmp_path):
+    """#2426: a `git fetch` failure (returncode 128 here covers both "branch
+    genuinely doesn't exist on the remote" and "transient network/auth
+    blip" — the two are indistinguishable from the exit code alone) must NOT
+    collapse into `False`. `False` is reserved for a check that actually
+    completed and counted zero commits; a failed fetch produced no such
+    count, so it is `None` — "couldn't verify" — not "verified empty"."""
     _calls, scripted = recorded_git
     (tmp_path / ".git").mkdir()
     scripted[("fetch", "b")] = (128, "")
     s = state(work_branch="b")
-    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is False
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_the_target_fetch_fails(
+    recorded_git, tmp_path
+):
+    """Same #2426 distinction, for the OTHER fetch (`origin/<target>`)."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("fetch", "main")] = (128, "")
+    s = state(work_branch="b", repo_default_branch="main")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
 
 
 def test_the_verifiers_are_inert_without_a_local_checkout(tmp_path):
+    """#2426: no local checkout means no evidence either way — `None`, not
+    `False`. `verify_merged` is untouched by #2426 (GitHub is its primary
+    source of truth, not this local checkout) and keeps its `False`."""
     verifier = GitMergeVerifier(repo_path=str(tmp_path / "nope"))
     s = state(work_branch="b", repo_github="")
-    assert verifier.branch_has_commits(s) is False
+    assert verifier.branch_has_commits(s) is None
     assert verifier.verify_merged(s) is False
 
 

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/tui/src/app/pipeline.rs

@@ -6084,6 +6084,24 @@ impl CoordApp {
                         label = format!("{}\n{}", label, reason);
                     }
                 }
+                // #2427: annotate the box a dead-end `coord escalate record`
+                // actually named — e.g. `coord drive` died with "review came
+                // back request-changes and no loop dispatches a fix for this
+                // row" (`coord.dead_end`'s terminal-and-unactionable shapes,
+                // or `coord.drive._escalate_merge`) — but until now that
+                // board record only surfaced as a sidebar-row "[stuck]"
+                // badge (`escalation_badge_span`, a different splice point:
+                // the Pipeline list, not this per-issue Overview strip) or
+                // an operator-pulled `coord escalate list`. Matched on
+                // `esc.stage == name` so only the box the driver actually
+                // blamed gets the marker, not every stage on the row.
+                if let Some(repo) = issue.coord_repo.as_deref() {
+                    if let Some(esc) = self.escalation_for(repo, issue.number) {
+                        if esc.stage == *name {
+                            label = format!("{}\n⚠ blocked — see Log", label);
+                        }
+                    }
+                }
                 // Skipped counts as "settled" for prior_all_done: a closed-issue
                 // stage that never ran is logically done.
                 let prior_all_done = statuses[..i]

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/tui/src/app/tests.rs

@@ -12365,6 +12365,63 @@
         assert!(label.contains("needs a person"), "got: {label}");
     }
 
+    /// #2427: a dead-end `coord escalate record` naming this issue's Review
+    /// stage — the shape `coord.dead_end`/`coord.drive._escalate_dead_end`
+    /// writes when a `request-changes` verdict has nothing left to dispatch
+    /// a fix for — must annotate the Review box on the Overview strip, not
+    /// just the sidebar-row "[stuck]" badge (`escalation_badge_span`) or an
+    /// operator-pulled `coord escalate list`.
+    #[test]
+    fn build_pipeline_widget_annotates_stage_named_by_open_escalation() {
+        let mut app = make_pipeline_app();
+        app.data.assignments.push(_stage_assignment("w1", "work", 1.0, "done"));
+        app.data.assignments.push(_stage_assignment("r1", "review", 3.0, "done"));
+        app.data.escalations.push(EscalationEntry {
+            id: 1,
+            repo_name: "api".to_string(),
+            issue_number: 42,
+            stage: "review".to_string(),
+            assignment_id: Some("r1".to_string()),
+            reason: "review_terminal_no_verdict: review r1 reached status=done \
+                     carrying NO verdict"
+                .to_string(),
+            gate_readings: "review_status=done | review_verdict=(none)".to_string(),
+            proposed_command: "coord report-result --assignment r1 ...".to_string(),
+            created_at: Some(1.0),
+        });
+
+        let view = app.build_pipeline_widget().unwrap();
+        let review_label = &view.stages[1].label;
+        assert!(
+            review_label.contains("blocked"),
+            "an open escalation naming the Review stage must annotate its box: got {review_label:?}"
+        );
+        assert!(
+            review_label.contains("see Log"),
+            "the annotation must point the operator at the Log tab: got {review_label:?}"
+        );
+        // The Merge box's own escalation-record check must not fire for a
+        // record whose `stage` is "review" — only the named box gets marked.
+        let merge_label = &view.stages[2].label;
+        assert!(
+            !merge_label.contains("blocked"),
+            "an escalation record scoped to Review must not also mark Merge: got {merge_label:?}"
+        );
+    }
+
+    /// A per-issue Overview box must stay unannotated when there is no open
+    /// escalation for this (repo, issue) at all — the common case, and a
+    /// regression guard against the #2427 annotation firing unconditionally.
+    #[test]
+    fn build_pipeline_widget_no_escalation_annotation_when_none_open() {
+        let mut app = make_pipeline_app();
+        app.data.assignments.push(_stage_assignment("w1", "work", 1.0, "done"));
+        app.data.assignments.push(_stage_assignment("r1", "review", 3.0, "done"));
+
+        let view = app.build_pipeline_widget().unwrap();
+        assert_eq!(view.stages[1].label, "Review");
+    }
+
     /// A `merged` row in merge_queue makes the Merge stage Done.
     #[test]
     fn merge_stage_status_done_from_merge_queue() {

{code_coordinator-0.5.165 → code_coordinator-0.5.167}/tui/src/app/types.rs

@@ -814,10 +814,8 @@ pub(crate) struct EscalationEntry {
     pub(crate) id: i64,
     pub(crate) repo_name: String,
     pub(crate) issue_number: i64,
-    // Parsed for wire parity / `Debug` dumps and reachable via `coord
-    // escalate list` outside the TUI; not yet surfaced on the Pipeline
-    // row/menu, which only needs `reason` + `proposed_command` today.
-    #[allow(dead_code)]
+    // #2427: which stage box on the Overview strip gets the "blocked" mark
+    // — see `CoordApp::build_pipeline_widget`'s `esc.stage == name` check.
     #[serde(default)]
     pub(crate) stage: String,
     #[allow(dead_code)]
@@ -827,7 +825,7 @@ pub(crate) struct EscalationEntry {
     /// Human-readable "key=value | key=value" summary of the gate readings
     /// the driver observed — deliberately NOT JSON (see `coord/db.py`): this
     /// record exists to be read by a human, not machine-parsed.
-    #[allow(dead_code)] // see `stage` above — not yet surfaced in the TUI
+    #[allow(dead_code)] // not yet surfaced in the TUI (unlike `stage`, #2427)
     #[serde(default)]
     pub(crate) gate_readings: String,
     pub(crate) proposed_command: String,