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

{code_coordinator-0.5.753 → code_coordinator-0.5.754}/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.754}/PKG-INFO

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

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

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

{code_coordinator-0.5.753 → code_coordinator-0.5.754}/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.754}/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.754}/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.754}/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.754}/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.754}/tests/test_cli_drive_queue.py

@@ -3455,6 +3455,215 @@ def test_exhausted_ci_stale_escalation_proposes_revalidate_not_a_requeue(
     assert proposed == f"coord merge --revalidate --only {REPO}#2983"
 
 
+def test_a_size_triage_pending_refusal_parks_and_resumes_on_verdict(
+    cli, seed, launches, coord_db,
+):
+    """#3971, end-to-end — the quadraui#2304 incident reproduced and fixed.
+    `coord.dispatch.enforce_preflight_guard`'s "a size-triage review is
+    running ... retry once it posts its verdict" refusal carries the SAME
+    `EXIT_DISPATCH_REFUSED` exit code as the genuinely permanent refusal
+    pinned by the test just below, but it is TEMPORARY: the row must PARK,
+    not BLOCK, with `attempts` untouched, while the triage leg is in
+    flight, and must resume to `waiting` — and relaunch, same tick — the
+    first tick after that leg's own `review_target` assignment goes
+    terminal. No queue surgery, no cascaded `blocked` on any `after=`
+    dependent.
+    """
+    from coord.audit import record_audit
+    from coord.decomposition_chat import (
+        SIZE_TRIAGE_PENDING_MARKER,
+        size_triage_review_target_for,
+    )
+    from coord.drive import EXIT_DISPATCH_REFUSED
+
+    seed(issues={2304: "open"})
+    cli("add", REPO, "2304")
+    cli("tick")
+    assert queued(2304)["attempts"] == 0
+
+    refusal = (
+        "drive exited for claude-coordinator#2304 (exit_code="
+        f"{EXIT_DISPATCH_REFUSED}): dispatch failed: issue #2304 flagged "
+        "by the preflight size scorer (score 4/4): 3 file(s) declared. A "
+        "size-triage review is running on 'dellserver' "
+        "(review_target='size-triage-2304') — retry once it posts its "
+        f"verdict. {SIZE_TRIAGE_PENDING_MARKER}"
+    )
+    launched_at = queued(2304)["launched_at"]
+    _backdate(2304, DRIVE_STARTUP_GRACE_SECONDS + 60)
+    record_audit(
+        tier="business", category="drive", event_type="drive_exited",
+        actor="drive", summary=refusal, repo=REPO, issue=2304,
+        ts=launched_at + 5,
+        details={"exit_code": EXIT_DISPATCH_REFUSED, "error": refusal},
+    )
+
+    # The triage leg itself is still on the board, non-terminal.
+    review_target = size_triage_review_target_for(2304)
+    coord_db.execute(
+        "INSERT INTO assignments "
+        "(assignment_id, repo_name, issue_number, issue_title, "
+        " machine_name, type, status, review_target, dispatched_at) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            "triage-2304", REPO, 2304, "[size-triage] issue 2304",
+            "dellserver", "review", "running", review_target, launched_at + 1,
+        ),
+    )
+    coord_db.commit()
+
+    result = cli("tick")
+    assert result.exit_code == 0, result.output
+    assert len(launches) == 1, launches  # parked, not retried — no relaunch
+
+    entry = queued(2304)
+    assert entry["state"] == "parked"
+    assert entry["attempts"] == 0
+    assert SIZE_TRIAGE_PENDING_MARKER in entry["last_reason"]
+
+    # The triage leg posts its verdict and goes terminal.
+    coord_db.execute(
+        "UPDATE assignments SET status = 'done' WHERE assignment_id = ?",
+        ("triage-2304",),
+    )
+    coord_db.commit()
+
+    resumed = cli("tick")
+    assert resumed.exit_code == 0, resumed.output
+    assert len(launches) == 2, launches  # resumed AND relaunched, same tick
+
+    entry = queued(2304)
+    assert entry["state"] == "running"
+    assert entry["attempts"] == 0
+
+
+def _size_triage_parked_entry(issue: int):
+    """A `parked`-on-size-triage-pending queue entry, for the shell-half
+    tests below."""
+    from coord.decomposition_chat import SIZE_TRIAGE_PENDING_MARKER
+    from coord.drive_queue import STATE_PARKED, QueueEntry
+
+    return QueueEntry(
+        repo=REPO, issue=issue, position=1, state=STATE_PARKED,
+        last_reason=(
+            f"issue #{issue} flagged by the preflight size scorer — retry "
+            f"once it posts its verdict. {SIZE_TRIAGE_PENDING_MARKER}"
+        ),
+    )
+
+
+def _triage_row(issue: int, status: str, *, repo: str = REPO) -> dict:
+    from coord.decomposition_chat import size_triage_review_target_for
+
+    return {
+        "assignment_id": f"triage-{issue}",
+        "repo_name": repo,
+        "issue_number": issue,
+        "type": "review",
+        "status": status,
+        "review_target": size_triage_review_target_for(issue),
+    }
+
+
+def test_fetch_size_triage_pending_reads_the_routed_board_not_the_local_db(
+    monkeypatch,
+):
+    """#3971 shell half, #615: the triage leg's status must come from the
+    board payload `_fetch_board_payload` resolves — the daemon's `GET
+    /board` on a thin client, the local DB only when no `board_service` is
+    configured — never from a direct `coord.state.build_board`, which
+    silently reads an empty board on a thin client. `build_board` is
+    booby-trapped here, so a regression back to the local read fails this
+    test rather than quietly answering "nothing in flight"."""
+    import coord.commands.drive_queue as dq
+    import coord.state as state_mod
+
+    def exploding_build_board():
+        raise AssertionError("build_board must not be called — read is routed")
+
+    monkeypatch.setattr(state_mod, "build_board", exploding_build_board)
+    monkeypatch.setattr(
+        dq, "_fetch_board_payload",
+        lambda: {"assignments": [_triage_row(2304, "running")]},
+    )
+
+    entry = _size_triage_parked_entry(2304)
+    assert dq._fetch_size_triage_pending([entry]) == {entry.key: True}
+
+
+def test_fetch_size_triage_pending_clears_once_the_triage_leg_is_terminal(
+    monkeypatch,
+):
+    import coord.commands.drive_queue as dq
+
+    monkeypatch.setattr(
+        dq, "_fetch_board_payload",
+        lambda: {"assignments": [_triage_row(2304, "done")]},
+    )
+
+    entry = _size_triage_parked_entry(2304)
+    assert dq._fetch_size_triage_pending([entry]) == {entry.key: False}
+
+
+def test_fetch_size_triage_pending_ignores_a_same_target_row_in_another_repo(
+    monkeypatch,
+):
+    """`review_target` is only unique within a repo — a still-running
+    `size-triage-2304` in a DIFFERENT repo must not keep this entry
+    parked, and must not be mistaken for this one's verdict either."""
+    import coord.commands.drive_queue as dq
+
+    monkeypatch.setattr(
+        dq, "_fetch_board_payload",
+        lambda: {
+            "assignments": [
+                _triage_row(2304, "running", repo="other-repo"),
+                _triage_row(2304, "done"),
+            ]
+        },
+    )
+
+    entry = _size_triage_parked_entry(2304)
+    assert dq._fetch_size_triage_pending([entry]) == {entry.key: False}
+
+
+def test_fetch_size_triage_pending_fails_closed_on_an_unreadable_board(
+    monkeypatch,
+):
+    """An unreadable board is not evidence that the triage finished: the
+    entry stays parked rather than resuming Work dispatch against an issue
+    a paid triage session may still be about to split."""
+    import coord.commands.drive_queue as dq
+
+    def boom():
+        raise RuntimeError("daemon unreachable")
+
+    monkeypatch.setattr(dq, "_fetch_board_payload", boom)
+
+    entry = _size_triage_parked_entry(2304)
+    assert dq._fetch_size_triage_pending([entry]) == {entry.key: True}
+
+
+def test_fetch_size_triage_pending_ignores_other_parks_and_reads_no_board(
+    monkeypatch,
+):
+    """No board read at all on a tick where nothing is parked this way —
+    the common case."""
+    import coord.commands.drive_queue as dq
+    from coord.drive_queue import STATE_PARKED, QueueEntry
+
+    def boom():
+        raise AssertionError("no board read when nothing is parked on triage")
+
+    monkeypatch.setattr(dq, "_fetch_board_payload", boom)
+
+    entry = QueueEntry(
+        repo=REPO, issue=2304, position=1, state=STATE_PARKED,
+        last_reason="CI running: checks pending",
+    )
+    assert dq._fetch_size_triage_pending([entry]) == {}
+
+
 def test_a_permanent_dispatch_refusal_blocks_on_the_first_tick_no_attempt_spent(
     cli, seed, launches,
 ):

{code_coordinator-0.5.753 → code_coordinator-0.5.754}/tests/test_decomposition_chat.py

@@ -1749,6 +1749,47 @@ class TestSizeTriageReviewTargetFor:
             int(target)
 
 
+class TestIsSizeTriageReviewTarget:
+    """#3971: the inverse of `size_triage_review_target_for` — recognising a
+    size-triage `review_target` back out of a board row, so a caller like
+    `coord.notify` can tell it apart from a real PR review."""
+
+    def test_recognises_its_own_sentinel(self):
+        target = decomposition_chat.size_triage_review_target_for(3818)
+        assert decomposition_chat.is_size_triage_review_target(target) is True
+
+    def test_rejects_a_real_pr_number(self):
+        assert decomposition_chat.is_size_triage_review_target("42") is False
+
+    def test_rejects_none_and_empty(self):
+        assert decomposition_chat.is_size_triage_review_target(None) is False
+        assert decomposition_chat.is_size_triage_review_target("") is False
+
+
+class TestIsSizeTriagePendingReason:
+    """#3971: the marker `enforce_preflight_guard` embeds in its "retry
+    once it posts its verdict" refusal, and nothing else, so
+    `coord.drive_queue._reconcile_running` can park on it instead of
+    blocking on the generic `exit_refused` classification every other
+    `DispatchRefused` shares."""
+
+    def test_recognises_the_marker(self):
+        text = (
+            f"issue #99 flagged ... retry once it posts its verdict. "
+            f"{decomposition_chat.SIZE_TRIAGE_PENDING_MARKER}"
+        )
+        assert decomposition_chat.is_size_triage_pending_reason(text) is True
+
+    def test_rejects_unrelated_text(self):
+        assert decomposition_chat.is_size_triage_pending_reason(
+            "issue #99 is part of oracle-opted-in milestone ms-51"
+        ) is False
+
+    def test_rejects_none_and_empty(self):
+        assert decomposition_chat.is_size_triage_pending_reason(None) is False
+        assert decomposition_chat.is_size_triage_pending_reason("") is False
+
+
 class TestBuildSizeTriageBriefing:
     def test_includes_issue_body_and_contract(self):
         briefing = decomposition_chat.build_size_triage_briefing(