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

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

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

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

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

{code_coordinator-0.5.752 → code_coordinator-0.5.753}/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.753}/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.753}/coord/review.py

@@ -1238,6 +1238,33 @@ def parse_review_from_agent(
     return _parse_review_from_lines(lines, stream_json=stream_json)
 
 
+def _review_findings_from_comments(
+    comments: list[dict], assignment_id: str
+) -> ReviewFindings | None:
+    """Shared core of :func:`fetch_review_findings_from_github` and
+    :func:`fetch_review_findings_from_github_many` — extracts *one*
+    assignment's findings out of an already-fetched comment list, so a
+    multi-round fold (:func:`coord.merge_queue._issue_resolution_for_entry`)
+    can fetch the comment list ONCE and look up every round in it, instead
+    of one full `gh` round trip per round (#3966).
+    """
+    from coord.comments import extract_findings_block  # noqa: PLC0415
+
+    if not assignment_id:
+        return None
+    # Newest-first so a re-review's findings win over an earlier iteration's.
+    for c in reversed(comments):
+        hit = extract_findings_block(c.get("body", ""), assignment_id)
+        if hit is not None:
+            verdict, body = hit
+            return ReviewFindings(
+                verdict=verdict or "request-changes",
+                body=body,
+                issue_resolution=parse_issue_resolution(body),
+            )
+    return None
+
+
 def fetch_review_findings_from_github(
     repo_github: str,
     issue_number: int,
@@ -1255,11 +1282,15 @@ def fetch_review_findings_from_github(
     Routed through :func:`coord.github_ops.get_issue_comments` (#1483) rather
     than shelling out to ``gh`` directly — ``github_ops`` is the single ``gh``
     sink so a GitLab/bare-DB backend has one seam to sit beside.
+
+    Fetches the comment list on every call — a caller recovering MULTIPLE
+    assignments' findings off the same issue (e.g. folding a whole review
+    chain) should use :func:`fetch_review_findings_from_github_many` instead,
+    which does exactly one fetch for all of them.
     """
     import subprocess as _sp  # noqa: PLC0415
 
     from coord import github_ops  # noqa: PLC0415
-    from coord.comments import extract_findings_block  # noqa: PLC0415
 
     if not (repo_github and assignment_id):
         return None
@@ -1267,17 +1298,38 @@ def fetch_review_findings_from_github(
         comments = github_ops.get_issue_comments(repo_github, issue_number)
     except (RuntimeError, _sp.TimeoutExpired, OSError, ValueError):
         return None
-    # Newest-first so a re-review's findings win over an earlier iteration's.
-    for c in reversed(comments):
-        hit = extract_findings_block(c.get("body", ""), assignment_id)
-        if hit is not None:
-            verdict, body = hit
-            return ReviewFindings(
-                verdict=verdict or "request-changes",
-                body=body,
-                issue_resolution=parse_issue_resolution(body),
-            )
-    return None
+    return _review_findings_from_comments(comments, assignment_id)
+
+
+def fetch_review_findings_from_github_many(
+    repo_github: str,
+    issue_number: int,
+    assignment_ids: Iterable[str],
+) -> dict[str, ReviewFindings]:
+    """Batch form of :func:`fetch_review_findings_from_github` (#3966):
+    one `gh` comment-list fetch covering every *assignment_ids* entry,
+    instead of one fetch per entry — the cost a multi-round review-chain
+    fold (:func:`coord.merge_queue._issue_resolution_for_entry`) would
+    otherwise pay on every tick. Missing/unrecoverable entries are simply
+    absent from the returned dict rather than raising.
+    """
+    import subprocess as _sp  # noqa: PLC0415
+
+    from coord import github_ops  # noqa: PLC0415
+
+    ids = [a for a in assignment_ids if a]
+    if not (repo_github and ids):
+        return {}
+    try:
+        comments = github_ops.get_issue_comments(repo_github, issue_number)
+    except (RuntimeError, _sp.TimeoutExpired, OSError, ValueError):
+        return {}
+    result: dict[str, ReviewFindings] = {}
+    for assignment_id in ids:
+        findings = _review_findings_from_comments(comments, assignment_id)
+        if findings is not None:
+            result[assignment_id] = findings
+    return result
 
 
 # ── Test-gate verdict output parsing (#1351) ────────────────────────────────
@@ -5933,6 +5985,7 @@ def build_scoped_review_briefing(
     prior_verdict: str = "approve",
     prior_findings_body: str | None = None,
     is_base_move: bool = False,
+    prior_issue_resolution: "IssueResolution | None" = None,
 ) -> str:
     """Assemble a SCOPED re-review briefing (#1476, widened by #3161).
     Pure function — testable.
@@ -5954,6 +6007,23 @@ def build_scoped_review_briefing(
       handed the prior review's findings (*prior_findings_body*) alongside
       the delta, and is asked to confirm each blocking finding was actually
       addressed rather than told to avoid re-litigating anything.
+
+    *prior_issue_resolution* (#3966): the prior review's own separate
+    `ISSUE_RESOLUTION:` judgment (:func:`coord.models.parse_issue_resolution`
+    applied to *prior_findings_body* — not a `## Blocking findings` entry,
+    so a reviewer told only to "check each blocking finding"/"this PR was
+    already approved" never re-checks it on its own). When it is
+    `partial`/`investigation`, this briefing echoes it verbatim — after
+    whichever of the three premises above applies (fix round, base move,
+    or conflict-fix rebase; a prior APPROVING review can carry a `partial`
+    judgment too, see #3502) — and instructs the reviewer to re-check it
+    explicitly, and to state their own `ISSUE_RESOLUTION:` line either way
+    — never just drop it. A `None` or `resolved` prior resolution adds
+    nothing here; this function always asks for the reviewer's own
+    `ISSUE_RESOLUTION:` line regardless, since
+    :func:`coord.merge_queue._issue_resolution_for_entry` carries the prior
+    round's value forward when a re-review's own line is missing, and a
+    missing line must never silently read as "resolved".
     """
     is_fix_round = prior_verdict != "approve"
     lines: list[str] = []
@@ -6030,6 +6100,50 @@ def build_scoped_review_briefing(
             "something either side of the conflict needed."
         )
         lines.append("")
+    if prior_issue_resolution is not None and prior_issue_resolution.value != "resolved":
+        # #3966: the prior review's `ISSUE_RESOLUTION:` judgment is a
+        # SEPARATE line from `## Blocking findings`/the approval itself, so
+        # neither "check each blocking finding" (fix-round path) nor "this
+        # PR was already approved" (base-move/conflict-rebase paths) ever
+        # re-checks it on its own — call it out explicitly as its own
+        # outstanding finding, regardless of which of the three premises
+        # above applies.
+        lines.append("## Prior ISSUE_RESOLUTION judgment (still outstanding)")
+        lines.append("")
+        reason_suffix = (
+            f" — {prior_issue_resolution.reason}"
+            if prior_issue_resolution.reason
+            else ""
+        )
+        lines.append(
+            f"`ISSUE_RESOLUTION: {prior_issue_resolution.value}{reason_suffix}`"
+        )
+        lines.append("")
+        recheck_subject = "the delta" if is_fix_round else "the current branch"
+        resolved_clause = (
+            "If the fix round actually completed what was missing, say so"
+            if is_fix_round
+            else "If the issue is in fact now fully resolved, say so"
+        )
+        lines.append(
+            "The prior review also recorded this SEPARATE judgment: "
+            "merging the PR as it stood did NOT fully resolve the "
+            "issue (code quality and 'does this actually fix the "
+            "reported bug' are different questions — see the "
+            "`ISSUE_RESOLUTION:` instructions below). Treat this "
+            f"exactly like a blocking finding: re-check it against {recheck_subject}. "
+            f"{resolved_clause} and record your own `ISSUE_RESOLUTION: "
+            "resolved`. If it is still not fully resolved — including "
+            "when this repo's own CLAUDE.md only allows specific "
+            "narrow partials (e.g. a declared tranche, a one-backend "
+            "leftover, an upstream blocker) and this one doesn't "
+            "qualify — restate it explicitly with your own "
+            "`ISSUE_RESOLUTION: partial` or `investigation` line and "
+            "`request-changes`, naming what's still missing. Do NOT "
+            "just omit the line: a missing line is read as carrying "
+            "this judgment forward UNCHANGED, not as 'resolved'."
+        )
+        lines.append("")
     lines.append("## Context")
     lines.append(f"- Repo: {repo_github} (local name: {repo_name})")
     lines.append(f"- Branch: {branch or '(unknown)'}")
@@ -6125,6 +6239,7 @@ def build_scoped_review_briefing(
     lines.append("```")
     lines.append("REVIEW_VERDICT: approve")
     lines.append("REVIEW_BODY:")
+    lines.append("ISSUE_RESOLUTION: resolved")
     lines.append("<your full review text in markdown>")
     lines.append("END_REVIEW")
     lines.append("```")
@@ -6133,6 +6248,21 @@ def build_scoped_review_briefing(
         "Use `REVIEW_VERDICT: request-changes` if the resolution introduced "
         "a real bug."
     )
+    lines.append("")
+    lines.append(
+        "ALWAYS include your own `ISSUE_RESOLUTION:` line inside "
+        "`REVIEW_BODY:` (shown above), one of `resolved` | `partial` | "
+        "`investigation` — exactly the same judgment a normal review "
+        "states, and separate from `REVIEW_VERDICT:` (code quality and "
+        "'does this actually fix the reported bug' are different "
+        "questions). State it even when you have nothing new to add: a "
+        "missing line is read as carrying the PRIOR review's own "
+        "`ISSUE_RESOLUTION:` judgment forward UNCHANGED (#3966), never as "
+        "`resolved` by default — so omitting it does not clear a prior "
+        "`partial`/`investigation`, it only leaves the coordinator "
+        "guessing. If the prior review's judgment was already `resolved` "
+        "(or absent), `resolved` is the right default here too."
+    )
     lines.append(
         "BODY STRUCTURE — same three headings as a normal review, always "
         "all three: `## Blocking findings`, `## Non-blocking concerns`, "
@@ -6423,6 +6553,18 @@ def dispatch_scoped_review(
         if _prior_findings is not None:
             prior_findings_body = _prior_findings.body
 
+    # #3966: re-parsed from the recovered body text rather than trusting
+    # `_prior_findings.issue_resolution` — `_load_review_findings`'s DB-cache
+    # fast path (the common case: `notify`/`report-result` already cached
+    # verdict+body for this exact row) constructs its `ReviewFindings`
+    # without ever parsing one, so that attribute silently defaults to
+    # "resolved" regardless of what the body actually says. Re-parsing the
+    # body text here is the one parse both paths (DB-cache and log/agent
+    # fallback) can rely on alike.
+    prior_issue_resolution = (
+        parse_issue_resolution(prior_findings_body) if prior_findings_body else None
+    )
+
     # #1476 fix: rank candidates against the machine that authored the code
     # under review — the WORK assignment behind *entry* — not the prior
     # reviewer's machine. ``QueuedMerge`` doesn't carry the worker's machine
@@ -6607,6 +6749,7 @@ def dispatch_scoped_review(
                 prior_verdict=prior_review_verdict,
                 prior_findings_body=prior_findings_body,
                 is_base_move=is_base_move,
+                prior_issue_resolution=prior_issue_resolution,
             )
 
             payload = {