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

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

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

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

{code_coordinator-0.5.752 → 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.752 → 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.752 → 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.752 → 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.752 → code_coordinator-0.5.754}/coord/merge_queue.py

@@ -7798,14 +7798,72 @@ def _work_assignment_for_entry(entry: QueuedMerge, board) -> Assignment | None:
     return None
 
 
+def _review_chain_for_entry(entry: QueuedMerge, board) -> list[Assignment]:
+    """Every ``type="review"`` :class:`Assignment` covering *entry*'s work
+    chain (:func:`_chain_work_ids`), oldest first.
+
+    A scoped re-review (#1476/#3161) carries the SAME
+    ``review_of_assignment_id`` as the round it supersedes (see
+    :func:`coord.review.dispatch_scoped_review`'s docstring) rather than
+    chaining to the previous review row, so there is no parent/child link
+    between successive review rounds to walk — only ``dispatched_at`` order
+    distinguishes "this round" from "the one before it". Used by
+    :func:`_issue_resolution_for_entry` (#3966) to fold EVERY round's own
+    `ISSUE_RESOLUTION:` judgment forward, not just the one that ended up
+    approving.
+    """
+    if board is None:
+        return []
+    pool = list(getattr(board, "completed", []) or []) + list(getattr(board, "active", []) or [])
+    branch_work_ids = _chain_work_ids(entry, pool)
+    if not branch_work_ids:
+        return []
+    reviews = [
+        a for a in pool
+        if getattr(a, "type", None) == "review"
+        and getattr(a, "review_of_assignment_id", None) in branch_work_ids
+    ]
+    reviews.sort(key=lambda a: getattr(a, "dispatched_at", None) or 0.0)
+    return reviews
+
+
 def _issue_resolution_for_entry(
     entry: QueuedMerge, board, gh_ops: "GhOps | None" = None, config=None,
 ) -> IssueResolution:
-    """(#3502) The EFFECTIVE `ISSUE_RESOLUTION:` verdict for *entry* — the
-    worker's own judgment (its `completion_summary`), folded with the
-    approving reviewer's judgment (when one exists), reviewer winning any
-    disagreement that makes it MORE cautious, never less
-    (:func:`coord.models.effective_issue_resolution`).
+    """(#3502, widened by #3966) The EFFECTIVE `ISSUE_RESOLUTION:` verdict
+    for *entry*, computed in two stages so the settled #3502 "never the
+    reverse" guarantee (a REVIEWER can never silently downgrade the
+    WORKER's own `partial`/`investigation` self-report back to "resolved")
+    stays intact while also fixing #3966 (a scoped re-review that drops a
+    PRIOR REVIEW ROUND's `partial`):
+
+    1. Fold every review round's own judgment together, chronologically,
+       among THEMSELVES. Each fold normally wins any disagreement that
+       makes it MORE cautious, never less
+       (:func:`coord.models.effective_issue_resolution`) — UNLESS a later
+       round's judgment is an EXPLICIT `ISSUE_RESOLUTION: resolved` (its
+       ``explicit`` bit set, meaning that reviewer actually wrote the
+       marker rather than leaving it out), in which case that later,
+       independent opinion wins outright and clears whatever an earlier
+       round accumulated. A round that states no `ISSUE_RESOLUTION:` line
+       of its own parses to the same "resolved" VALUE but with
+       ``explicit=False``, indistinguishable from silence, so it can never
+       drop a prior round's `partial`/`investigation` — only an explicit
+       restatement can.
+    2. Combine that folded reviewer verdict with the WORKER's own judgment
+       (its `completion_summary`) exactly once, via the same
+       :func:`coord.models.effective_issue_resolution` — which is where
+       "never the reverse" actually lives: even an explicit, unanimous
+       "resolved" from every review round can never undo the worker's own
+       `partial`/`investigation` admission.
+
+    Folds the WHOLE review chain, not just the rounds up to the one that
+    happened to approve: `scan_approved_reviews` can pick an arbitrary
+    approving round among several with no recorded `review_patch_id`
+    (pre-#821 rows), and truncating there risked silently dropping a
+    LATER round's more-cautious judgment. Since the fold is monotonically
+    cautious except for the explicit-"resolved" escape hatch above,
+    folding everything is strictly safer than guessing a cutoff.
 
     Both halves degrade gracefully to "resolved" (today's unconditional
     behaviour) when unavailable:
@@ -7813,11 +7871,14 @@ def _issue_resolution_for_entry(
     * *board* is ``None``, or the originating `work` assignment can't be
       found on it (:func:`_work_assignment_for_entry`) — no worker claim to
       read.
-    * No approving review is found (:func:`scan_approved_reviews`), or its
-      findings can't be recovered from the GitHub message bus
-      (:func:`coord.review.fetch_review_findings_from_github` — the one
-      review-findings source this module can reach without a notify.py/
-      state.py DB round trip) — no reviewer claim to read.
+    * No approving review is found (:func:`scan_approved_reviews`) — no
+      reviewer claim to read at all. When one is found, every round's
+      findings are recovered from the GitHub message bus in a SINGLE fetch
+      (:func:`coord.review.fetch_review_findings_from_github_many` — the
+      one review-findings source this module can reach without a
+      notify.py/state.py DB round trip); a round missing from the result
+      (comment never posted, or the fetch failed outright) simply doesn't
+      contribute to the fold.
 
     Deferred-imports `coord.review` to avoid a circular import (`review.py`
     does not import `merge_queue.py` at module level, but keeping the
@@ -7837,20 +7898,39 @@ def _issue_resolution_for_entry(
     reviewer_resolution: IssueResolution | None = None
     if board is not None:
         scan = scan_approved_reviews(entry, board, gh_ops, config=config)
-        review_assignment = scan.review_assignment
-        if scan.approved and review_assignment is not None:
-            from coord.review import fetch_review_findings_from_github  # noqa: PLC0415
+        if scan.approved and scan.review_assignment is not None:
+            from coord.review import fetch_review_findings_from_github_many  # noqa: PLC0415
 
+            # Fold EVERY round in the chain (not just up to the one that
+            # approved — see the docstring above on why no cutoff is used).
+            chain = _review_chain_for_entry(entry, board)
             try:
-                findings = fetch_review_findings_from_github(
+                findings_by_id = fetch_review_findings_from_github_many(
                     entry.repo_github,
                     entry.issue_number,
-                    review_assignment.assignment_id,
+                    (a.assignment_id for a in chain),
                 )
-            except Exception:  # noqa: BLE001 — best-effort; falls back to the worker's claim
-                findings = None
-            if findings is not None:
-                reviewer_resolution = findings.issue_resolution
+            except Exception:  # noqa: BLE001 — best-effort; keeps the running fold
+                findings_by_id = {}
+
+            for round_assignment in chain:
+                findings = findings_by_id.get(round_assignment.assignment_id)
+                if findings is None:
+                    continue
+                candidate = findings.issue_resolution
+                if reviewer_resolution is None:
+                    reviewer_resolution = candidate
+                elif candidate.explicit and candidate.value == "resolved":
+                    # A later, independent review round that DELIBERATELY
+                    # restates "resolved" (not a missing line defaulting to
+                    # it) may clear what an earlier review round
+                    # accumulated — reviewer rounds re-checking each other
+                    # is exactly what #3966 asks for.
+                    reviewer_resolution = candidate
+                else:
+                    reviewer_resolution = effective_issue_resolution(
+                        reviewer_resolution, candidate
+                    )
 
     return effective_issue_resolution(worker_resolution, reviewer_resolution)
 

{code_coordinator-0.5.752 → code_coordinator-0.5.754}/coord/models.py

@@ -714,10 +714,27 @@ class IssueResolution:
     remainder after the value (e.g. "the quadraui issue was only drafted,
     not filed"), empty when the marker carried none or wasn't present at
     all.
+
+    ``explicit`` (#3966) is the presence bit: ``True`` only when
+    :func:`parse_issue_resolution` actually matched a real marker in the
+    source text, ``False`` for the default it returns when none was found
+    (or the text was empty/``None``). Without this bit, a round that
+    states nothing and a round that explicitly writes
+    ``ISSUE_RESOLUTION: resolved`` are the same value and indistinguishable
+    — which is exactly what let a multi-round fold (#3966's
+    `coord.merge_queue._issue_resolution_for_entry`) never clear a prior
+    `partial`/`investigation`, even when a later, independent reviewer
+    deliberately restated `resolved`. Callers that fold multiple rounds
+    together use this bit to tell "silent" (carry the prior value forward)
+    apart from "stated" (let it win the tie); callers combining a single
+    worker/reviewer pair (:func:`effective_issue_resolution`) do not need
+    it — "never the reverse" there is unconditional regardless of how the
+    reviewer's value was produced.
     """
 
     value: str = DEFAULT_ISSUE_RESOLUTION
     reason: str = ""
+    explicit: bool = False
 
 
 # Mirrors `SMOKE_TESTS:`/`REVIEW_VERDICT:`'s tolerance for trailing
@@ -794,6 +811,12 @@ def parse_issue_resolution(text: str | None) -> IssueResolution:
     quotations of the marker text, not claims. A real, unquoted marker
     earlier in the text still wins once every later quoted mention has
     been skipped, rather than falling all the way back to the default.
+
+    The returned :class:`IssueResolution`'s ``explicit`` bit (#3966) is
+    ``True`` only on the "found a real marker" return below — the
+    absent/malformed default always comes back with ``explicit=False``,
+    so a caller folding several of these together can tell a genuine
+    `ISSUE_RESOLUTION: resolved` apart from a line that was never written.
     """
     if not text:
         return IssueResolution()
@@ -808,7 +831,7 @@ def parse_issue_resolution(text: str | None) -> IssueResolution:
         ).strip()
         if is_blank_issue_resolution_reason(reason):
             reason = ""
-        return IssueResolution(value=value, reason=reason)
+        return IssueResolution(value=value, reason=reason, explicit=True)
     return IssueResolution()
 
 

{code_coordinator-0.5.752 → 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