code-coordinator 0.5.753__tar.gz → 0.5.755__tar.gz

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/CLAUDE.md

@@ -140,7 +140,9 @@ in [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md#design-decisions--the-settled-r
   session on a *different* machine reviews your diff against this file, with **zero shared
   context with you** — so your diff and final message must stand on their own. Put the
   *why* of a fix in the commit message and final message, not in code comments: comments
-  describe the code as it is, with no issue numbers or "used to" history.
+  describe the code as it is, with no issue numbers or "used to" history. **An unplanned
+  `ISSUE_RESOLUTION: partial` is a blocking finding** (scope you cut yourself, or a call
+  site left unwired); only an upstream blocker or a tranche the issue defines is allowed.
 
 ## Rules for workers
 

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.753",
+  "tag": "0.5.755",
   "distance": 0,
-  "node": "g543afc164f9f6d8411574fa781b778d6f50b5d56",
+  "node": "g7b46fbb3e62c0f7e3e7d877b23ebe7bbf4cfdf34",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-11-10"

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/agent.py

@@ -30,6 +30,7 @@ from typing import TYPE_CHECKING, Any, Callable, Iterable
 from coord import cargo_cache
 from coord.claude_setup_token import inject_setup_token
 from coord.config_reload import reload_config_if_stale
+from coord.decomposition_chat import is_size_triage_review_target
 from coord.models import DELIVERABLE_ANALYSIS_LABEL
 from coord.platform_paths import default_coord_dir
 from coord.smoke_tags import smoke_leg_capabilities
@@ -11971,7 +11972,20 @@ class AgentServer:
             # timeout (60 s) but MUST NOT let a hung push block the
             # status update — so we catch both _GitError *and*
             # subprocess.TimeoutExpired and treat both as non-fatal.
-            if assignment.worktree_path:
+            # #3975: a size-triage leg is read-only by its own system prompt
+            # (`build_size_triage_briefing` forbids commits) and its branch
+            # is cut fresh from the default branch's tip with zero commits
+            # of its own. Pushing that branch anyway gives #3376's
+            # issue-scoped `any_matching_branch_merged` fallback a
+            # zero-commit `issue-N-size-triage-*` branch to mis-read as
+            # "already merged" (it's an ancestor of the default branch),
+            # which refuses the very Work dispatch the triage verdict just
+            # unblocked. Skip the push entirely for this leg shape — there
+            # is nothing of this leg's own to push, so there's nothing lost.
+            _is_size_triage_leg = is_size_triage_review_target(
+                getattr(assignment.spec, "review_target", None)
+            )
+            if assignment.worktree_path and not _is_size_triage_leg:
                 wt_path = Path(assignment.worktree_path)
                 if wt_path.exists() and exit_code == 0:
                     # #3869: a history-rewrite leg (today, only

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/claim.py

@@ -478,7 +478,7 @@ def _default_branch_lookup(repo_github: str, issue_number: int) -> list[str]:
 # distinction has to be verified per-dispatcher, not assumed; see the
 # issue's suggested structural alternative (branch never had commits, ever)
 # for a fix that wouldn't require keeping this list exhaustive by hand.
-_OBSERVER_LEG_TAGS = ("review", "scoped-review", "smoke", "gate-b")
+_OBSERVER_LEG_TAGS = ("review", "scoped-review", "smoke", "gate-b", "size-triage")
 
 
 def _is_observer_leg_branch(branch: str, issue_number: int) -> bool:

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/commands/drive_queue.py

@@ -5842,6 +5842,72 @@ def _fetch_gate_a_pending(entries: list) -> dict[str, bool]:
     return pending
 
 
+def _fetch_size_triage_pending(entries: list) -> dict[str, bool]:
+    """``{entry_key: still_waiting_on_the_triage_leg}`` for every entry
+    parked on `coord.dispatch.enforce_preflight_guard`'s size-triage-pending
+    refusal (#3971, `coord.decomposition_chat.SIZE_TRIAGE_PENDING_MARKER`).
+
+    Re-derives the SAME evidence `enforce_preflight_guard` itself consults
+    on its next real invocation — a matching `review_target` row's own
+    `status` column (#2096: one question, one answer) — rather than a
+    second, independent notion of "is the triage done". Board read only, no
+    `gh` call, and no work at all on a tick where nothing is parked this
+    way (the common case).
+
+    Reads the raw ``assignments`` rows out of :func:`_fetch_board_payload`
+    rather than `coord.state.build_board`, for the #615 reason every other
+    reader in this module routes: that fetch answers from the daemon's
+    ``GET /board`` when ``board_service`` is configured and from the local
+    DB only when it is not, so a thin client sees the real rows instead of
+    an empty board. `BoardView` cannot answer this one — it reduces the
+    board to per-issue facts and carries no ``review_target`` at all — and
+    the triage row is keyed by ``review_target``, not by its issue.
+
+    Fails **closed**, same posture as :func:`_fetch_gate_a_pending`: an
+    entry whose triage status can't be confirmed stays parked. Being wrong
+    that way costs a parked row an operator can see and release; being
+    wrong the other way resumes Work dispatch while a paid triage session
+    might still be about to propose splitting this issue into pieces no
+    single worker should touch at once. A board the fetch CAN read that
+    simply carries no row for this ``review_target`` is a different
+    answer, not an unreadable one — nothing is in flight, so the entry
+    resumes and the relaunch's own guard call re-derives the verdict.
+    """
+    from coord.decomposition_chat import (  # noqa: PLC0415
+        is_size_triage_pending_reason,
+        size_triage_review_target_for,
+    )
+    from coord.drive_state import TERMINAL_STATUSES  # noqa: PLC0415
+
+    targets = [
+        e for e in entries
+        if e.state == STATE_PARKED
+        and is_size_triage_pending_reason(getattr(e, "last_reason", "") or "")
+    ]
+    if not targets:
+        return {}
+
+    try:
+        payload = _fetch_board_payload()
+    except Exception:  # noqa: BLE001 — fail closed, stay parked
+        return {e.key: True for e in targets}
+
+    rows = payload.get("assignments") or []
+    pending: dict[str, bool] = {}
+    for e in targets:
+        review_target = size_triage_review_target_for(e.issue)
+        matches = [
+            r for r in rows
+            if (r.get("review_target") or "") == review_target
+            and (r.get("repo_name") or "") == e.repo
+        ]
+        pending[e.key] = any(
+            str(r.get("status") or "").lower() not in TERMINAL_STATUSES
+            for r in matches
+        )
+    return pending
+
+
 def _fetch_live_ci_gate(
     entries: list, config_path: Path | None
 ) -> tuple[dict[str, bool], dict[str, str]]:
@@ -8509,6 +8575,13 @@ def drive_queue_tick(
         # tick when no entry is parked that way — which is the common case.
         gate_a_pending = _fetch_gate_a_pending(entries)
 
+        # #3971: the same live re-read, for every entry parked on a size-
+        # triage review still in flight — see `_fetch_size_triage_pending`'s
+        # docstring for the incident this closes (a flagged issue's
+        # drive-queue row, and every `after=` dependent behind it, stuck
+        # `blocked` even after the triage leg posted `proceed`).
+        size_triage_pending = _fetch_size_triage_pending(entries)
+
         # #2182: for every entry parked on a CI reason, a fresh single-entry
         # re-derivation of its gate, taken live THIS tick — see
         # `_fetch_live_ci_gate`'s docstring for the gap this closes (a park
@@ -8614,6 +8687,7 @@ def drive_queue_tick(
             exit_refused=exit_refused,
             exit_dead_end=exit_dead_end,
             gate_a_pending=gate_a_pending,
+            size_triage_pending=size_triage_pending,
             cordons=cordons,
             no_eligible_host=no_eligible_host,
             live_ci_gate=live_ci_gate,

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/decomposition_chat.py

@@ -1024,16 +1024,50 @@ def size_triage_review_target_for(issue_number: int) -> str:
 
     Mirrors `coord.gate_b.review_target_for`: keeping it non-int-parseable
     means `coord.notify._try_parse_and_post_review`'s `int(review_target)`
-    sniff falls through to "post as a plain issue comment" rather than
-    mistaking this for a per-issue code review of a real PR — and this
-    entry posts no comment at all (see `dispatch_size_triage_review`), so in
-    practice nothing ever reads this string back out of `coord.notify`; it
-    exists so `latest`-style lookups (if one is ever needed) can find this
-    assignment unambiguously among a repo's other `type="review"` rows.
+    sniff falls through rather than mistaking this for a per-issue code
+    review of a real PR. It also exists so `latest`-style lookups (if one
+    is ever needed) can find this assignment unambiguously among a repo's
+    other `type="review"` rows, and so `coord.notify.notify`'s own
+    completion handler (#3971) can recognise this ONE `type="review"`
+    shape and skip review-findings extraction / the "Review assignment
+    completed" comment for it — a leg this dispatch-time sentinel marks is
+    a read-only size triage, never a real code review, whatever its
+    board-row `type` says.
     """
     return f"size-triage-{issue_number}"
 
 
+def is_size_triage_review_target(review_target: str | None) -> bool:
+    """Whether *review_target* identifies a size-triage dispatch rather than
+    a real code review (#3971) — the inverse of
+    :func:`size_triage_review_target_for`, for a caller holding only the
+    string back out of an `Assignment` row.
+    """
+    return bool(review_target) and str(review_target).startswith("size-triage-")
+
+
+# #3971: a TEMPORARY wait, not a permanent pre-dispatch guard refusal
+# (#1844) — unlike `enforce_oracle_readiness`/`enforce_epic_dispatch_guard`'s
+# refusals, `enforce_preflight_guard`'s "a size-triage review is running —
+# retry once it posts its verdict" refusal clears on its own the moment that
+# leg reaches a terminal status, no operator action needed. Embedded in that
+# refusal's text so `coord.drive_queue._reconcile_running` can recognise it
+# BEFORE the generic `exit_refused` → `blocked` branch (#1844) every other
+# `DispatchRefused` falls into, and park instead — the same precedent
+# `coord.gate_a.is_gate_a_refusal_reason`'s own marker set for a refusal with
+# a self-clearing condition. Lives here, not in `coord.dispatch`, because
+# this module already owns every other size-triage-shaped sentinel
+# (`size_triage_review_target_for`, `is_size_triage_review_target`) and
+# `coord.dispatch`/`coord.drive_queue` both already import from it.
+SIZE_TRIAGE_PENDING_MARKER = "[size-triage-pending]"
+
+
+def is_size_triage_pending_reason(text: str | None) -> bool:
+    """Whether *text* is `enforce_preflight_guard`'s triage-in-flight
+    refusal (#3971) — see :data:`SIZE_TRIAGE_PENDING_MARKER`."""
+    return bool(text) and SIZE_TRIAGE_PENDING_MARKER in text
+
+
 SIZE_TRIAGE_SYSTEM_PROMPT = """You are an independent triage agent dispatched by the coordinator to \
 decide whether a single GitHub issue, already flagged by a heuristic size \
 scorer as plausibly too large for one worker, should be split into smaller \

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/dispatch.py

@@ -450,6 +450,7 @@ def enforce_preflight_guard(
         return
 
     from coord.decomposition_chat import (  # noqa: PLC0415
+        SIZE_TRIAGE_PENDING_MARKER,
         SizeTriageError,
         dispatch_size_triage_review,
         size_triage_review_target_for,
@@ -540,12 +541,22 @@ def enforce_preflight_guard(
             # follow-up in flight to ever clear the refusal.
             return
 
+    # #3971: this refusal is TEMPORARY — the triage leg just dispatched (or
+    # already in flight) clears it on its own the moment it posts a
+    # verdict, unlike `enforce_oracle_readiness`/`enforce_epic_dispatch_
+    # guard`'s refusals above, which nothing but an operator action can
+    # clear. `SIZE_TRIAGE_PENDING_MARKER` lets `coord.drive_queue.
+    # _reconcile_running` tell this ONE `DispatchRefused` shape apart from
+    # every other one sharing the same `EXIT_DISPATCH_REFUSED` exit code
+    # (#1844) and park the drive-queue row instead of blocking it forever —
+    # see that function's #3971 comment for the quadraui#2304 incident this
+    # closes.
     raise DispatchRefused(
         f"issue #{issue_number} flagged by the preflight size scorer "
         f"(score {score.total:g}/{score.threshold:g}): {score.reason}. "
         f"A size-triage review is {'already ' if in_flight is not None else ''}"
         f"running on {machine.name!r} (review_target={review_target!r}) — "
-        "retry once it posts its verdict."
+        f"retry once it posts its verdict. {SIZE_TRIAGE_PENDING_MARKER}"
     )
 
 

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/drive_queue.py

@@ -91,6 +91,7 @@ from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any, Iterable, Mapping, Sequence
 
+from coord.decomposition_chat import is_size_triage_pending_reason
 from coord.drive_state import TERMINAL_STATUSES, WORK_LIKE
 from coord.entry_truth import (
     EntryTruth,
@@ -5804,6 +5805,45 @@ def _reconcile_running(
             None,
         )
 
+    # #3971 rides the SAME "pending verdict, not a standing refusal" shape
+    # as #2063's Gate-A park immediately above: `coord.dispatch.
+    # enforce_preflight_guard`'s "a size-triage review is running — retry
+    # once it posts its verdict" refusal is TEMPORARY — the condition that
+    # refused it (a non-terminal triage leg) clears on its own the moment
+    # that leg finishes, no operator action needed — yet it reached here as
+    # a PLAIN `EXIT_DISPATCH_REFUSED` (#1844's exit code for every
+    # `DispatchRefused`, permanent or not) and would otherwise fall straight
+    # into the `exit_refused` → `blocked` branch below and stay blocked
+    # forever even after the verdict posts PROCEED (quadraui#2304, 2026-11-10
+    # UTC: every dependent behind the row cascaded to `blocked` three minutes
+    # before the triage leg itself returned `proceed`). Checked purely off
+    # `own_reason`'s marker — independent of `exit_refused` — the same
+    # "recognise this refusal by its own text, not by the exit code every
+    # `DispatchRefused` shares" posture #2063/#2234 already established.
+    # Parks rather than blocks; `plan_tick`'s pre-pass below un-parks it the
+    # tick after the matching `review_target` assignment goes terminal, same
+    # "no queue surgery needed" contract Gate-A's park gives.
+    if own_reason and is_size_triage_pending_reason(own_reason):
+        reason = (
+            f"{own_reason} — parking without spending an attempt; the queue "
+            "resumes it automatically once the size-triage review posts its "
+            "verdict, no queue surgery needed (#3971)"
+        )
+        return (
+            Reconcile(
+                entry.key,
+                "parked",
+                reason,
+                occupies=False,
+                updates={
+                    "state": STATE_PARKED,
+                    "last_reason": reason,
+                    "session_name": None,
+                },
+            ),
+            None,
+        )
+
     # #2234 rides the SAME evidence as `refused` below (the drive's own
     # `drive_exited` reason) but, like #2063 above, reaches the OPPOSITE
     # conclusion from a PLAIN `EXIT_TERMINAL_FAILURE` — `coord.drive.
@@ -7602,6 +7642,7 @@ def plan_tick(
     exit_refused: Mapping[str, bool] | None = None,
     exit_dead_end: Mapping[str, bool] | None = None,
     gate_a_pending: Mapping[str, bool] | None = None,
+    size_triage_pending: Mapping[str, bool] | None = None,
     cordons: Mapping[str, str] | None = None,
     no_eligible_host: Mapping[str, str] | None = None,
     live_ci_gate: Mapping[str, bool] | None = None,
@@ -8656,6 +8697,41 @@ def plan_tick(
             states[entry.key] = STATE_WAITING
             effective_attempts[entry.key] = 0  # #2273: see #2182 branch above
             continue
+        # #3971: the SAME "external verdict, re-check every tick" shape as
+        # the Gate-A branch just above, for `enforce_preflight_guard`'s
+        # size-triage-pending park. The shell resolves `size_triage_pending`
+        # by re-reading the matching `review_target` assignment's own
+        # `status` column — a local board read, no `gh` call per entry; an
+        # entry it can't resolve stays parked, same fail-closed posture as
+        # Gate-A's. Resuming does NOT itself decide proceed/split — it only
+        # lets the next real `enforce_preflight_guard` call run again, which
+        # is what actually consumes the verdict (falls through for PROCEED/
+        # unparseable, raises a fresh — unmarked, permanent — refusal that
+        # supersedes the original for SPLIT).
+        if is_size_triage_pending_reason(entry.last_reason):
+            if (size_triage_pending or {}).get(entry.key, True):
+                continue
+            reason = (
+                f"the size-triage review for {entry.key} has posted its "
+                "verdict — resuming from parked without spending an "
+                "attempt (#3971)"
+            )
+            reconciles.append(
+                Reconcile(
+                    entry.key,
+                    "resumed",
+                    reason,
+                    occupies=False,
+                    updates={
+                        "state": STATE_WAITING,
+                        "attempts": 0,
+                        "last_reason": reason,
+                    },
+                )
+            )
+            states[entry.key] = STATE_WAITING
+            effective_attempts[entry.key] = 0
+            continue
         # #2234: a policy-refusal park has NO external verdict to poll for —
         # the rule it names is standing, not pending — so unlike the Gate-A
         # branch just above, this one never resumes itself. Without this

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/gates.py

@@ -201,9 +201,24 @@ class GateReport:
 
 
 def _row_from_assignment(a: "Assignment") -> AssignmentGateRow:
+    from coord.decomposition_chat import is_size_triage_review_target  # noqa: PLC0415
+
+    # #3975: a size-triage leg is dispatched with `type="review"` only to
+    # reuse coord.agent's read-only deny-list for that type — it never
+    # produces a REVIEW_VERDICT and is not evidence toward the issue's
+    # review gate. Label the raw row "size-triage" instead of "review" so
+    # `coord gates`' row listing (and its `--json`/`report_to_dict` form)
+    # can't be mistaken for the issue's actual review stage — see
+    # `build_gate_report`'s `work_like` gate above, which already excludes
+    # this row from ever backing a "review" GateDecision.
+    row_type = (
+        "size-triage"
+        if a.type == "review" and is_size_triage_review_target(a.review_target)
+        else (a.type or "work")
+    )
     return AssignmentGateRow(
         assignment_id=a.assignment_id,
-        type=a.type or "work",
+        type=row_type,
         status=a.status,
         branch=a.branch,
         machine_name=a.machine_name,

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/notify.py

@@ -49,6 +49,7 @@ from coord.comments import (
     format_stuck,
 )
 from coord.config import Config
+from coord.decomposition_chat import is_size_triage_review_target
 from coord.dispatch import (
     AGENT_PORT,
     post_advisory,
@@ -4452,6 +4453,31 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
             EVENT_PLAN if posted else EVENT_COMPLETION,
             branch=entry.get("branch"),
         )
+    elif (
+        transition.event == EVENT_COMPLETION
+        and assignment_type == "review"
+        and is_size_triage_review_target(record.get("review_target"))
+    ):
+        # #3971: a size-triage leg (`coord.decomposition_chat.
+        # dispatch_size_triage_review`) is dispatched as `type="review"`
+        # ONLY to reuse `coord.agent`'s CLI-enforced read-only deny-list for
+        # that type (see that function's own comment) — it is never a real
+        # code review, has no PR to review, and (per its own briefing) never
+        # emits REVIEW_VERDICT/END_REVIEW. Before this branch existed, the
+        # generic `assignment_type == "review"` arm below tried to extract
+        # findings from a `SIZE_TRIAGE_VERDICT`-shaped log, failed, and
+        # posted "Review assignment completed but findings could not be
+        # extracted" to the issue (quadraui#2304, 2026-11-10 UTC) — a
+        # confusing, actionable-looking comment about a leg that already
+        # posts no comment at all by design (`dispatch_size_triage_review`'s
+        # own docstring). `coord.dispatch.enforce_preflight_guard` is what
+        # actually consumes this leg's verdict (fetching and parsing the
+        # raw log itself the next time it runs) — nothing here needs to.
+        mark_notified(
+            transition.assignment_id,
+            transition.event,
+            branch=entry.get("branch"),
+        )
     elif transition.event == EVENT_COMPLETION and assignment_type == "review":
         # For review assignments, parse the structured findings and post as a
         # PR review (or issue comment when no PR number is available).  Fall

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/coord/stage_projection.py

@@ -34,6 +34,7 @@ from __future__ import annotations
 import dataclasses
 from typing import Any, Protocol, runtime_checkable
 
+from coord.decomposition_chat import is_size_triage_review_target
 from coord.models import CLOSES_ISSUE_TYPES, WORK_LIKE_TYPES, effective_issue_number
 # #3191: the two #3182 fan-out encodings this module has to PARSE to count
 # Test *rounds* rather than raw smoke rows — see `_test_stage_leg_count`.
@@ -167,6 +168,16 @@ def assignments_for_stage(
     ``require_plan`` and no ``type="plan"`` assignment for this issue),
     plan-typed assignments fold into "work" so a ``--plan-only`` dispatch
     without ``require_plan`` doesn't disappear from the Work stage.
+
+    #3975: a size-triage leg is dispatched with ``type="review"`` purely to
+    reuse ``coord.agent``'s read-only deny-list for that type (see
+    ``coord.decomposition_chat.dispatch_size_triage_review``'s own comment)
+    — it is not a code review and carries no ``review_verdict`` a real
+    review would. Counting it toward the "review" stage painted
+    quadraui#2304's board as "review" while Work hadn't even been
+    dispatched yet (a size-triage leg's ``status="running"`` trips the
+    ACTIVE check in ``stage_status_for`` before any work row exists). Drop
+    it here, once, rather than at every stage-status call site.
     """
     fold_plan_into_work = (
         stage == "work"
@@ -175,6 +186,8 @@ def assignments_for_stage(
     )
     out = []
     for a in assignments_for_issue:
+        if is_size_triage_review_target(getattr(a, "review_target", None)):
+            continue
         t = a.type or "work"
         if fold_plan_into_work:
             if t in ("work", "plan"):

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/tests/test_agent_push_failure.py

@@ -22,6 +22,16 @@ history has actually been rewritten). `TestHistoryRewriteLegSafetyNetPush`
 below covers the `--force-with-lease` push this file's `_HISTORY_REWRITE_
 TYPES` leg now uses instead, and the promotion of a non-fast-forward/
 stale-lease rejection to the same FAILED outcome as an auth break.
+
+#3975: a size-triage leg (`coord.decomposition_chat.dispatch_size_triage_
+review`) is read-only by its own system prompt and its branch is cut fresh
+from the default branch's tip, so this reap-time safety-net push has
+nothing of the leg's own to push in the first place — and pushing the
+empty branch anyway hands #3376's `any_matching_branch_merged` fallback a
+zero-commit `issue-N-size-triage-*` branch to mis-read as "already
+merged", refusing the Work dispatch the triage verdict just unblocked
+(quadraui#2304). `test_size_triage_leg_reap_skips_the_push` below pins
+down that this reap-time push is never even attempted for that leg shape.
 """
 
 from __future__ import annotations
@@ -508,6 +518,52 @@ def test_successful_push_leaves_push_failure_reason_none(
     server.shutdown()
 
 
+def test_size_triage_leg_reap_skips_the_push(
+    tmp_path: Path, repo_with_rejecting_remote: tuple[Path, Path]
+) -> None:
+    """#3975: a size-triage leg's reap must never attempt the
+    belt-and-suspenders push at all — not even one that would otherwise
+    fail loudly. The rejecting remote proves the point: if reap attempted
+    the push, this leg would come back FAILED with an auth-shaped
+    `push_failure_reason`; since the leg is read-only, it must instead come
+    back DONE with no push attempted and no branch created on origin."""
+    clone, origin = repo_with_rejecting_remote
+    server = AgentServer(
+        machine_name="t",
+        repos=["api"],
+        repo_paths={"api": str(clone)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/sh", "-c", "true"],  # read-only, no commits
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(clone),
+        issue_number=2304,
+        issue_title="[size-triage] shared app layer 2a widgetid",
+        briefing="b",
+        branch="main",
+        type="review",
+        review_target="size-triage-2304",
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == DONE
+    assert final.push_failure_reason is None
+    log_text = Path(final.log_path).read_text()
+    assert "# reap: push starting" not in log_text
+    assert "# reap: push completed" not in log_text
+    # The branch the agent would have minted (`issue-2304-size-triage-...`)
+    # must never reach origin — the whole bug was that empty branch landing
+    # there and being misread as "this issue's work already merged".
+    refs = subprocess.run(
+        ["git", "ls-remote", "--heads", str(origin)],
+        capture_output=True, text=True, check=True,
+    ).stdout
+    assert "size-triage" not in refs
+    server.shutdown()
+
+
 @pytest.fixture
 def repo_with_existing_branch(tmp_path: Path) -> tuple[Path, Path]:
     """A clone with `origin` configured and a `feature` branch already

{code_coordinator-0.5.753 → code_coordinator-0.5.755}/tests/test_claim.py

@@ -973,12 +973,37 @@ def test_any_matching_branch_merged_issue_scoped_ignores_gate_b_leg(
     assert claim_mod.any_matching_branch_merged("acme/vimcode", 900) is False
 
 
+def test_any_matching_branch_merged_issue_scoped_ignores_size_triage_leg(
+    monkeypatch,
+) -> None:
+    """#3975: quadraui#2304's exact shape — a zero-commit
+    `issue-{N}-size-triage-*` branch (cut from the default branch's tip by
+    the read-only size-triage leg) sitting at `ahead_by == 0`, with no real
+    work branch dispatched yet. `any_matching_branch_merged` with no
+    *branch* (the dispatch-liveness fallback a re-queued Work dispatch
+    hits right after the triage leg says `proceed`) must not read the
+    triage branch as "this issue's work already merged" — that misread is
+    exactly what refused the Work dispatch in the incident."""
+    import coord.claim as claim_mod
+
+    monkeypatch.setattr(
+        "coord.github_ops._gh",
+        _gh_stub_with_matching_refs(
+            ["issue-2304-size-triage-shared-app-layer-2a-widgetid"],
+            "develop",
+            {"issue-2304-size-triage-shared-app-layer-2a-widgetid": 0},
+        ),
+    )
+    assert claim_mod.any_matching_branch_merged("acme/vimcode", 2304) is False
+
+
 def test_is_observer_leg_branch_matches_review_scoped_review_smoke_and_gate_b() -> None:
-    """#3442: the exact prefixes review/smoke/gate-b legs mint, and nothing
-    else — a bare `issue-N-review` (no trailing content) and the slugified
-    `issue-N-review-...`/`issue-N-scoped-review-...`/`issue-N-smoke-...`/
-    `issue-N-gate-b-...` shapes all match; an unrelated branch, or one that
-    merely CONTAINS "review" past the issue-number prefix, must not."""
+    """#3442/#3975: the exact prefixes review/smoke/gate-b/size-triage legs
+    mint, and nothing else — a bare `issue-N-review` (no trailing content)
+    and the slugified `issue-N-review-...`/`issue-N-scoped-review-...`/
+    `issue-N-smoke-...`/`issue-N-gate-b-...`/`issue-N-size-triage-...` shapes
+    all match; an unrelated branch, or one that merely CONTAINS "review"
+    past the issue-number prefix, must not."""
     import coord.claim as claim_mod
 
     assert claim_mod._is_observer_leg_branch("issue-9-review", 9) is True
@@ -990,6 +1015,9 @@ def test_is_observer_leg_branch_matches_review_scoped_review_smoke_and_gate_b()
     assert claim_mod._is_observer_leg_branch(
         "issue-9-gate-b-ms-9-milestone-verdict", 9
     ) is True
+    assert claim_mod._is_observer_leg_branch(
+        "issue-9-size-triage-shared-app-layer", 9
+    ) is True
     assert claim_mod._is_observer_leg_branch("issue-9-real-work", 9) is False
     assert claim_mod._is_observer_leg_branch(
         "issue-9-reviewer-onboarding", 9