code-coordinator 0.5.580__tar.gz → 0.5.582__tar.gz

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.580
+Version: 0.5.582
 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.580 → code_coordinator-0.5.582}/code_coordinator.egg-info/SOURCES.txt

@@ -724,6 +724,7 @@ tests/test_machine_onboard.py
 tests/test_machine_pause.py
 tests/test_machine_stats.py
 tests/test_merge_queue.py
+tests/test_merge_verification.py
 tests/test_merge_verify.py
 tests/test_milestone_chat.py
 tests/test_milestone_dispatch.py

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/code_coordinator.egg-info/scm_file_list.json

@@ -751,6 +751,7 @@
     "tests/test_machine_pause.py",
     "tests/test_machine_stats.py",
     "tests/test_merge_queue.py",
+    "tests/test_merge_verification.py",
     "tests/test_merge_verify.py",
     "tests/test_milestone_chat.py",
     "tests/test_milestone_dispatch.py",

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.580",
+  "tag": "0.5.582",
   "distance": 0,
-  "node": "gd3b3a8b69209767b94d3b03aeea8d17b2a32d9f9",
+  "node": "g66c11e8b562c82e18514dbd82f17849abf5c1df2",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/comments.py

@@ -84,6 +84,20 @@ EVENT_PHANTOM_HEALED = "phantom_row_healed"
 # the two are complementary, not overlapping. Like EVENT_PHANTOM_HEALED,
 # this narrates an action ALREADY TAKEN, not only a finding.
 EVENT_STUCK_TEST_STATE_HEALED = "stuck_test_state_healed"
+# #2109: the merge-time verification note — coordinator-assembled facts
+# (merge SHA, tests touched, Test/Review verdicts + machines, a harness-
+# limits caveat, a manual spot-check pointer) posted on the issue the
+# instant a `type="work"`-like entry merges. Distinct from every event
+# above: those all narrate a PIPELINE condition (stuck, stalled, healed);
+# this one exists so the richest account of a fix — today reachable only
+# via `git show` on the worker's own commit message (see #2109's own
+# issue body) — lands somewhere a human actually looks. Never worker-
+# authored prose: every field is derived from board state or the diff
+# (`coord.merge_queue._build_verification_comment`). Kept to exactly one
+# comment per issue — a second merge on the same issue (fix-1/retry
+# landing a second branch) UPDATES this comment in place
+# (`coord.state.upsert_issue_comment`) rather than appending a duplicate.
+EVENT_VERIFICATION = "verification"
 
 
 @dataclass
@@ -965,3 +979,156 @@ def format_plan(
         lines.append(estimate.strip())
 
     return "\n".join(lines)
+
+
+# ── Verification note (#2109) ────────────────────────────────────────────────
+
+_REPRO_HEADING_RE = re.compile(
+    r"^#{1,6}\s*(?:Repro(?:duce|duction)?(?:\s+steps)?|Steps\s+to\s+reproduce)\b"
+    r".*?\n(?P<body>.*?)(?=\n#{1,6}\s|\Z)",
+    re.IGNORECASE | re.DOTALL | re.MULTILINE,
+)
+
+
+def extract_repro_section(issue_body: str | None) -> str | None:
+    """Pull the repro/reproduction section out of an issue body, or
+    ``None`` when absent/blank.
+
+    Recognises ``## Repro``, ``## Reproduction``, ``## Repro steps``,
+    ``## Reproduce``, and ``## Steps to reproduce`` headings (#2109 review
+    nit — real issue bodies vary more than the original fixtures assumed).
+
+    Used by the #2109 verification note's manual spot-check section — the
+    one piece of the note that is quoted, not derived, and quoted from the
+    issue's OWN pre-fix text (never worker prose) so a human has concrete
+    steps to re-check against, not a restatement of the fix.
+    """
+    if not issue_body:
+        return None
+    m = _REPRO_HEADING_RE.search(issue_body)
+    if not m:
+        return None
+    body = m.group("body").strip()
+    return body or None
+
+
+_HARNESS_LIMIT_CAVEATS: dict[str, str] = {
+    "gtk": (
+        "This diff matched this repo's `gtk` capability rule. `GtkDriver` "
+        "synthesises `UiEvent`s directly, so a passing GTK Test/Review leg "
+        "does **not** exercise real GDK signal delivery, `EventController` "
+        "wiring, IME/dead keys, or painted geometry at real DPI."
+    ),
+    "tui": (
+        "This diff matched this repo's `tui` capability rule. `TestBackend` "
+        "does not parse real ANSI/SGR sequences, so a passing TUI Test/"
+        "Review leg does **not** confirm raw-mode input, real terminal "
+        "rendering, or mouse-event delivery."
+    ),
+    "browser": (
+        "This diff matched this repo's `browser` capability rule. A "
+        "headless-browser Test leg exercises the DOM but not every real "
+        "input path (native OS file pickers, drag-and-drop from outside "
+        "the browser, platform IME) — treat it as a strong but incomplete "
+        "proxy for a human driving the real UI."
+    ),
+}
+
+DEFAULT_HARNESS_LIMIT_CAVEAT = (
+    "No repo-specific harness-limits caveat is on file for the capability "
+    "(if any) this diff's `smoke_tests.capability_rules` matched — a green "
+    "Test/Review gate does not by itself prove every layer the change "
+    "touches was actually exercised."
+)
+
+
+def harness_limits_caveat(matched_capabilities: Iterable[str]) -> str:
+    """The standing #2109 caveat for the first of *matched_capabilities*
+    (in order) this module has a caveat on file for, or
+    :data:`DEFAULT_HARNESS_LIMIT_CAVEAT` when none match.
+
+    *matched_capabilities* is expected to come straight out of
+    ``coord.smoke.match_rules`` — the SAME `smoke_tests.capability_rules`
+    matcher Test-stage routing already uses, never a second,
+    independently-maintained file-pattern list (#2096, one question one
+    answer).
+    """
+    for cap in matched_capabilities:
+        caveat = _HARNESS_LIMIT_CAVEATS.get(cap)
+        if caveat:
+            return caveat
+    return DEFAULT_HARNESS_LIMIT_CAVEAT
+
+
+def format_verification(
+    *,
+    assignment_id: str,
+    repo_name: str,
+    issue_number: int,
+    branch: str,
+    merge_sha: str | None = None,
+    pr_number: int | None = None,
+    test_files: Iterable[str] = (),
+    test_verdict: str | None = None,
+    test_machine: str | None = None,
+    review_verdict: str | None = None,
+    review_machine: str | None = None,
+    harness_caveat: str = DEFAULT_HARNESS_LIMIT_CAVEAT,
+    repro: str | None = None,
+) -> str:
+    """Build the #2109 coordinator-assembled verification note.
+
+    Every field here is a fact the coordinator already holds — a merge SHA,
+    a diff-derived file list, a recorded gate verdict + the machine that
+    produced it, a repo-config-derived caveat, a quote from the issue's own
+    pre-fix ``## Repro`` section — never worker-authored prose. Posted (or
+    updated in place, see ``coord.state.upsert_issue_comment``) by
+    ``coord.merge_queue._maybe_post_verification`` the instant a merge
+    lands.
+    """
+    marker = _marker(
+        EVENT_VERIFICATION,
+        assignment=assignment_id,
+        repo=repo_name,
+        issue=issue_number,
+    )
+    branch_line = f"**Branch:** `{branch}`"
+    if pr_number is not None:
+        branch_line += f" (PR #{pr_number})"
+    test_files = list(test_files)
+    lines = [
+        "## 🔍 Coordinator: Verification note",
+        marker,
+        branch_line,
+        f"**Merge commit:** `{merge_sha}`" if merge_sha else "**Merge commit:** (not recorded)",
+        "",
+        "### Tests added/changed",
+        _fmt_files(test_files) if test_files else "(none detected in the diff)",
+        "",
+        "### Gate verdicts",
+        (
+            f"- **Test:** {test_verdict or '(no verdict recorded)'}"
+            + (f" — ran on `{test_machine}`" if test_machine else "")
+        ),
+        (
+            f"- **Review:** {review_verdict or '(no verdict recorded)'}"
+            + (f" — ran on `{review_machine}`" if review_machine else "")
+        ),
+        "",
+        "### Harness-limits caveat",
+        harness_caveat,
+        "",
+        "### Manual spot-check",
+        (
+            repro.strip()
+            if repro and repro.strip()
+            else (
+                f"No `## Repro` section found on issue #{issue_number} — "
+                "check the issue body directly."
+            )
+        ),
+        "",
+        "_Assembled automatically by the coordinator from board state and "
+        "the merged diff — not worker-authored._",
+    ]
+    return "\n".join(lines)

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/github_ops.py

@@ -1592,6 +1592,28 @@ def post_issue_comment(repo: str, issue_number: int, body: str):
     _capture_comment_write(repo, issue_number, body, url)
 
 
+def update_issue_comment(repo: str, issue_number: int, comment_id: int, body: str) -> None:
+    """Overwrite an existing issue comment's body in place (#2109) — the
+    update half of :func:`post_issue_comment`, so a standing marked comment
+    (e.g. the merge-time verification note, ``coord.state.
+    upsert_issue_comment``) can be refreshed on a second merge of the same
+    issue instead of appended as a duplicate.
+
+    *comment_id* is the numeric REST id (``parse_comment_id`` on a comment's
+    ``url``), not the GraphQL node id ``get_issue_comments`` returns as
+    ``id``. *issue_number* isn't read by the PATCH itself (GitHub addresses
+    a comment purely by its own id) — it's accepted anyway so the #873
+    capture-at-write mirror below is keyed exactly like
+    :func:`post_issue_comment`'s.
+    """
+    _gh(
+        "api", f"repos/{repo}/issues/comments/{comment_id}", "-X", "PATCH",
+        "-f", f"body={body}", caller="github_ops.update_issue_comment",
+    )
+    fake_url = f"https://github.com/{repo}/issues/{issue_number}#issuecomment-{comment_id}"
+    _capture_comment_write(repo, issue_number, body, fake_url)
+
+
 def _capture_comment_write(repo: str, issue_number: int, body: str, url: str) -> None:
     """Best-effort mirror of a just-posted comment into the durable
     ``issue_comments`` table (#873).

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/merge_queue.py

@@ -63,6 +63,7 @@ from coord.state import (
     comment_on_issue,
     dismiss_drive_escalation,
     record_uat_verdict,
+    upsert_issue_comment,
 )
 from coord.uat_checks import UatCheckResult, evaluate_uat_checks
 
@@ -7343,6 +7344,228 @@ def _maybe_push_status(
     return None
 
 
+# ── Verification note (#2109) ───────────────────────────────────────────────
+#
+# Today the richest, only POST-fix account of a merged change lives solely in
+# the worker's own commit message — reachable only via `git show`, not from
+# the issue, the PR, or the TUI (see #2109's own issue body for the vimcode
+# evidence). This posts a `<!-- coord:event=verification -->` comment on the
+# issue the instant a merge lands, assembled entirely from facts the
+# coordinator already holds (board state, the diff) — never worker-authored
+# prose, which would just reintroduce self-reporting.
+
+
+def _latest_review_assignment_for_entry(
+    entry: "QueuedMerge", board,
+) -> Assignment | None:
+    """The most-recently-dispatched verdict-bearing review :class:`Assignment`
+    covering *entry*'s work chain — the same walk :func:`_latest_review_verdict`
+    does, returning the Assignment itself (not just its verdict string) so a
+    caller can also read its ``machine_name``.
+    """
+    if board is None:
+        return None
+    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 None
+    reviews = [
+        a for a in pool
+        if getattr(a, "type", None) == "review"
+        and getattr(a, "review_of_assignment_id", None) in branch_work_ids
+        and getattr(a, "review_verdict", None) is not None
+    ]
+    if not reviews:
+        return None
+    return max(reviews, key=lambda a: getattr(a, "dispatched_at", None) or 0.0)
+
+
+def _latest_smoke_assignment_for_entry(
+    entry: "QueuedMerge", board,
+) -> Assignment | None:
+    """The most-recently-dispatched Test-stage (``type="smoke"``) child
+    :class:`Assignment` for the work assignment behind *entry*.
+
+    ``Assignment.test_state`` (the verdict) lives on the WORK row; the
+    machine that actually produced it lives on this child row — mirrors
+    :func:`_latest_review_assignment_for_entry`'s split for the same reason.
+    """
+    if board is None:
+        return None
+    work = _work_assignment_for_entry(entry, board)
+    if work is None:
+        return None
+    pool = list(getattr(board, "completed", []) or []) + list(getattr(board, "active", []) or [])
+    smokes = [
+        a for a in pool
+        if getattr(a, "type", None) == "smoke"
+        and getattr(a, "review_of_assignment_id", None) == getattr(work, "assignment_id", None)
+    ]
+    if not smokes:
+        return None
+    return max(smokes, key=lambda a: getattr(a, "dispatched_at", None) or 0.0)
+
+
+def _changed_test_files(
+    entry: "QueuedMerge", gh_ops: "GhOps", *, touched: list[str] | None = None,
+) -> list[str]:
+    """Test files touched by the branch that just merged, derived straight
+    from the diff (``gh_ops.get_compare_files``) — never from worker prose.
+
+    Heuristic file-PATH match only (no AST / ``#[test]`` parse): any
+    touched path under a ``test(s)/`` directory, or matching the common
+    ``test_*`` / ``*_test.*`` / ``*.test.*`` / ``*_spec.*`` / ``*.spec.*``
+    naming conventions. Best-effort — a lookup failure (or a stub ``GhOps``
+    that doesn't support ``get_compare_files`` returning falsy) yields an
+    empty list, never raises.
+
+    *touched*, when supplied, is an already-fetched ``get_compare_files``
+    result for this exact ``(target_branch, branch)`` pair — passed in by
+    ``_build_verification_comment`` so the two callers don't make the same
+    ``gh api compare`` round trip twice per merge (#2109 review, #2096: one
+    question, one answer). ``None`` (the default) fetches it here, unchanged
+    from this function's original standalone behaviour.
+    """
+    if touched is None:
+        try:
+            touched = gh_ops.get_compare_files(
+                entry.repo_github, entry.target_branch, entry.branch,
+            )
+        except Exception:  # noqa: BLE001 — best-effort, see docstring
+            touched = None
+    if not touched:
+        return []
+    out = []
+    for path in touched:
+        lower = f"/{path.lower()}"
+        base = lower.rsplit("/", 1)[-1]
+        if (
+            "/test/" in lower or "/tests/" in lower
+            or base.startswith("test_") or "_test." in base
+            or ".test." in base or "_spec." in base or ".spec." in base
+        ):
+            out.append(path)
+    return out
+
+
+def _matched_smoke_capabilities(touched_files: list[str], config) -> list[str]:
+    """Which ``smoke_tests.capability_rules`` capabilities *touched_files*
+    matches — via :func:`coord.smoke.match_rules`, the SAME matcher
+    Test-stage routing itself uses, so the #2109 harness-limits caveat below
+    can never silently disagree with what actually got routed (#2096, one
+    question one answer). Returns ``[]`` when *config* is ``None`` or
+    declares no capability rules.
+    """
+    from coord.smoke import match_rules  # noqa: PLC0415
+
+    smoke_cfg = getattr(config, "smoke_tests", None) if config is not None else None
+    rules = getattr(smoke_cfg, "capability_rules", None) or []
+    return match_rules(touched_files, rules)
+
+
+def _build_verification_comment(
+    entry: "QueuedMerge", board, gh_ops: "GhOps", config,
+) -> str:
+    """Assemble the #2109 merge-time verification note for *entry* — every
+    field a fact already on the board or in the diff, never worker prose.
+    """
+    from coord.comments import extract_repro_section, format_verification, harness_limits_caveat  # noqa: PLC0415
+
+    try:
+        touched = gh_ops.get_compare_files(
+            entry.repo_github, entry.target_branch, entry.branch,
+        ) or []
+    except Exception:  # noqa: BLE001 — best-effort
+        touched = []
+
+    # #2109 review: `entry.target_branch_head_sha` is captured BEFORE the
+    # merge (at the gating/staleness check, so `has_smoke_verdict` can tell
+    # whether the target moved since the test verdict was recorded) — it is
+    # by construction the PARENT commit, never the commit this merge just
+    # produced. Reusing it here would silently mislabel the verification
+    # note's headline "Merge commit" field with a stale pre-merge SHA (and,
+    # in a batch sharing one target branch, the same stale SHA across every
+    # entry in the group). This function is only ever called from
+    # `_maybe_post_verification`, strictly after `gh_ops.merge_pr(...)` has
+    # already succeeded, so a fresh fetch here is a genuinely different
+    # question from the pre-merge one above — not a redundant repeat of it —
+    # and is the only way to report the SHA the merge actually produced.
+    try:
+        merge_sha = gh_ops.get_branch_sha(entry.repo_github, entry.target_branch)
+    except Exception:  # noqa: BLE001 — best-effort
+        merge_sha = None
+
+    test_files = _changed_test_files(entry, gh_ops, touched=touched)
+
+    work = _work_assignment_for_entry(entry, board)
+    test_verdict = getattr(work, "test_state", None) if work is not None else None
+    smoke = _latest_smoke_assignment_for_entry(entry, board)
+    test_machine = getattr(smoke, "machine_name", None) if smoke is not None else None
+
+    review = _latest_review_assignment_for_entry(entry, board)
+    review_verdict = getattr(review, "review_verdict", None) if review is not None else None
+    review_machine = getattr(review, "machine_name", None) if review is not None else None
+
+    caveat = harness_limits_caveat(_matched_smoke_capabilities(touched, config))
+
+    get_issue = getattr(gh_ops, "get_issue", None)
+    repro: str | None = None
+    if get_issue is not None:
+        try:
+            issue_data = get_issue(entry.repo_github, entry.issue_number) or {}
+            repro = extract_repro_section(issue_data.get("body"))
+        except Exception:  # noqa: BLE001 — best-effort
+            repro = None
+
+    return format_verification(
+        assignment_id=entry.assignment_id,
+        repo_name=entry.repo_name,
+        issue_number=entry.issue_number,
+        branch=entry.branch,
+        merge_sha=merge_sha,
+        pr_number=entry.pr_number,
+        test_files=test_files,
+        test_verdict=test_verdict,
+        test_machine=test_machine,
+        review_verdict=review_verdict,
+        review_machine=review_machine,
+        harness_caveat=caveat,
+        repro=repro,
+    )
+
+
+def _maybe_post_verification(
+    entry: "QueuedMerge", board, gh_ops: "GhOps", config,
+) -> "MergeEvent | None":
+    """Post (or update in place) the #2109 verification note on *entry*'s
+    issue, right after a successful merge.
+
+    Scoped to ``CLOSES_ISSUE_TYPES`` entries — the same scope the close/
+    comment decision just above already uses, since a ``mock-author``/
+    ``test-author`` row has no single "did this fix the bug" question for a
+    verification note to answer. Best-effort, same posture as every other
+    post-merge hook in this block (:func:`_maybe_clear_expected_red`,
+    :func:`_maybe_push_design_round`, :func:`_maybe_push_status`): a failure
+    here is reported as an event and never undoes the merge that already
+    happened.
+    """
+    if entry.assignment_type not in CLOSES_ISSUE_TYPES:
+        return None
+    try:
+        body = _build_verification_comment(entry, board, gh_ops, config)
+    except Exception as e:  # noqa: BLE001 — best-effort, see docstring
+        return MergeEvent(entry, "verification_note_failed", str(e))
+    try:
+        upsert_issue_comment(
+            entry.repo_name, entry.issue_number, body, repo_github=entry.repo_github,
+        )
+    except Exception as e:  # noqa: BLE001 — best-effort, see docstring
+        return MergeEvent(entry, "verification_note_failed", str(e))
+    return MergeEvent(
+        entry, "verification_note_posted", f"posted/updated on issue #{entry.issue_number}",
+    )
+
+
 def process(
     items: list[QueuedMerge],
     gh_ops: GhOps,
@@ -8960,6 +9183,15 @@ def process(
                     status_event = MergeEvent(entry, "status_push_failed", str(e))
                 if status_event is not None:
                     events.append(status_event)
+                # #2109: the verification note — same best-effort posture as
+                # every hook above, posted last so it can read the freshest
+                # board/diff state this merge produced.
+                try:
+                    verification_event = _maybe_post_verification(entry, board, gh_ops, config)
+                except Exception as e:  # noqa: BLE001 — bookkeeping, never undoes a real merge
+                    verification_event = MergeEvent(entry, "verification_note_failed", str(e))
+                if verification_event is not None:
+                    events.append(verification_event)
                 continue
             entry.state = CONFLICT
             entry.error = msg

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/rest_schema.py

@@ -126,11 +126,14 @@ class IssueCommentCreate:
       durable ``issue_comments`` mirror (``/issue-comments`` ``capture``).
     * ``"sync"`` — backfill the mirror from the tracker
       (``/issue-comments`` ``sync``); ``body`` is not read.
+    * ``"upsert"`` (#2109) — post *body*, or edit an existing comment on the
+      same issue carrying the identical ``coord:event=...`` marker in place,
+      instead of appending a duplicate (``coord.state.upsert_issue_comment``).
     """
 
-    #: The comment text.  Required for ``post`` and ``capture``.
+    #: The comment text.  Required for ``post``, ``capture``, and ``upsert``.
     body: str | None = None
-    #: ``"post"`` | ``"capture"`` | ``"sync"``.  Defaults to ``"post"``.
+    #: ``"post"`` | ``"capture"`` | ``"sync"`` | ``"upsert"``.  Defaults to ``"post"``.
     action: str | None = None
     #: ``capture`` only: the tracker's own comment id, when known.
     gh_comment_id: int | None = None

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/review.py

@@ -3712,8 +3712,29 @@ def dispatch_review(
         # never match the merge-time `branch_patch_id`, which is computed from an
         # uncapped compare-API diff). The display copy shown to the reviewer is
         # then truncated locally from the same fetch — no second `gh` call.
+        #
+        # #2364: `pr` can legitimately be `None` here — the drive-queue path
+        # opens PRs lazily, so "review ran before the PR existed" is a normal
+        # timing, not an edge case. Previously that made `full_diff_text`
+        # (and therefore `review_patch_id` below) permanently `None` for such
+        # a review, which in turn made every later `review-reaffirm` against
+        # it fail forever with "missing patch-id data" even though the stored
+        # verdict was a real `approve`. Fall back to a direct branch-vs-base
+        # compare diff — the exact same API `github_ops.get_branch_patch_id`
+        # uses at merge time to fingerprint `branch_patch_id` — so the two
+        # sides of the "did the content change" question are always computed
+        # the same way, whether or not a PR happens to exist yet.
         _diff = diff_fetcher or github_ops.pr_diff
-        full_diff_text = _diff(repo.github, pr["number"], max_chars=None) if pr else None
+        if pr:
+            full_diff_text = _diff(repo.github, pr["number"], max_chars=None)
+        else:
+            _compare_diff_pre_pr = compare_diff_fetcher or github_ops.get_compare_diff
+            try:
+                full_diff_text = _compare_diff_pre_pr(
+                    repo.github, base_branch, completed.branch
+                )
+            except Exception:  # noqa: BLE001 — fail-safe: missing diff is not blocking
+                full_diff_text = None
 
         # #3196: cross-check `pr_diff`'s file list against a fresh, explicit
         # compare of the branch's own current refs before trusting it. A
@@ -3730,7 +3751,13 @@ def dispatch_review(
         # untrustworthy (not just that one file — a diff computed against
         # the wrong base is wrong throughout), so it's replaced outright by
         # the compare's own diff rather than patched.
-        if full_diff_text:
+        #
+        # #2364: skip entirely when `pr` is `None` — `full_diff_text` above
+        # already came straight from `get_compare_diff`/*compare_diff_fetcher*,
+        # the exact source this cross-check would otherwise fetch again to
+        # corroborate it against. Re-running it would just spend two more
+        # `gh` calls to confirm a diff agrees with itself.
+        if full_diff_text and pr:
             _compare_files = compare_files_fetcher or github_ops.get_compare_files
             try:
                 known_files = _compare_files(repo.github, base_branch, completed.branch)

{code_coordinator-0.5.580 → code_coordinator-0.5.582}/coord/serve_app.py

@@ -2927,7 +2927,7 @@ RPC_SUPERSEDED_BY_RESOURCE: dict[str, str] = {
     "/issue-comment": 'POST /issue/{repo_name}/{number}/comments ("action": "post")',
     "/issue-comments": (
         "GET /issue/{repo_name}/{number}/comments, or POST the same path with "
-        '"action": "capture" / "sync"'
+        '"action": "capture" / "sync" / "upsert"'
     ),
     "/assignment-usage": "PATCH /assignment/{assignment_id}",
     "/assignment-session-id": "PATCH /assignment/{assignment_id} (claude_session_id)",
@@ -3195,7 +3195,8 @@ def openapi_spec() -> dict:
                 "summary": (
                     "#1944: create or mirror one comment — the resource-shaped "
                     "stand-in for POST /issue-comment (action=post, the default) "
-                    "and POST /issue-comments (action=capture / action=sync)."
+                    "and POST /issue-comments (action=capture / action=sync / "
+                    "action=upsert, #2109)."
                 ),
                 "parameters": issue_path_params,
                 "requestBody": {
@@ -9940,6 +9941,9 @@ def build_app(
     async def post_issue_comments(request: Request) -> Response:
         # #873: capture-at-write / backfill-sync into the durable
         # issue_comments mirror on the canonical DB.
+        # #2109: also the ``"upsert"`` write for the merge-time verification
+        # note — edits a standing marked comment in place rather than
+        # posting a duplicate.
         from coord import state  # noqa: PLC0415
 
         body = await _read_json(request)
@@ -9964,6 +9968,14 @@ def build_app(
                     repo_github=body.get("repo_github"),
                 )
                 return JSONResponse({"synced": n})
+            if action == "upsert":
+                state._upsert_issue_comment_local(
+                    body["repo_name"],
+                    body["issue_number"],
+                    body["body"],
+                    repo_github=body.get("repo_github"),
+                )
+                return JSONResponse({"ok": True})
         except KeyError as e:
             return JSONResponse({"error": f"missing field: {e}"}, status_code=400)
         except Exception as e:  # noqa: BLE001
@@ -10167,7 +10179,8 @@ def build_app(
     async def post_issue_comments_resource(request: Request) -> Response:
         """#1944: ``POST /issue/{repo}/{n}/comments`` — the resource-shaped
         stand-in for /issue-comment (``action="post"``, the default) and
-        /issue-comments (``action="capture"`` / ``"sync"``)."""
+        /issue-comments (``action="capture"`` / ``"sync"`` / ``"upsert"``,
+        #2109)."""
         from coord import state  # noqa: PLC0415
 
         key = _resource_issue_key(request)
@@ -10184,11 +10197,11 @@ def build_app(
                 {"error": f"unknown field(s): {', '.join(unknown)}"}, status_code=400
             )
         action = body.get("action") or "post"
-        if action not in ("post", "capture", "sync"):
+        if action not in ("post", "capture", "sync", "upsert"):
             return JSONResponse(
                 {"error": f"unknown action: {action!r}"}, status_code=400
             )
-        if action in ("post", "capture") and not body.get("body"):
+        if action in ("post", "capture", "upsert") and not body.get("body"):
             return JSONResponse(
                 {"error": f"body is required for action {action!r}"}, status_code=400
             )
@@ -10210,6 +10223,13 @@ def build_app(
                     author=body.get("author"),
                     created_at=body.get("created_at"),
                 )
+            elif action == "upsert":
+                state._upsert_issue_comment_local(
+                    repo_name,
+                    number,
+                    body["body"],
+                    repo_github=body.get("repo_github"),
+                )
             else:
                 synced = state._sync_issue_comments_local(
                     repo_name, number, repo_github=body.get("repo_github")