code-coordinator 0.5.562__tar.gz → 0.5.563__tar.gz

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.562",
+  "tag": "0.5.563",
   "distance": 0,
-  "node": "g4c48decab602ab760461ff8d55ddd5db5baccd46",
+  "node": "gd370d95cd8b305a54b4761f01ee5c006b5fa5099",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-02"

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/coord/db.py

@@ -1087,7 +1087,27 @@ def retry_on_locked(
 # knows the table exists: `_ensure_archive_mirror` itself, unconditionally
 # and idempotently (`CREATE INDEX IF NOT EXISTS`) on every housekeeping
 # sweep — see that function's own comment in coord/housekeeping.py.
-_DB_SCHEMA_VERSION = 21
+#
+# #2468: bumped 21 -> 22 for the new `review_post_claims` TABLE above (not a
+# column — same shape as #3113/#3333's table-only bumps: `_migrate_add_
+# columns` below is unchanged, `CREATE TABLE IF NOT EXISTS` in `_SCHEMA_SQL`
+# is what actually creates it on an existing database). `_try_parse_and_
+# post_review` (the live completion path) and `post_orphaned_review_findings`
+# (the orphan sweep) both query "done reviews with `review_posted_at IS
+# NULL`" and only set `review_posted_at` AFTER successfully posting to
+# GitHub — two coordinator passes racing each other (one on the live path,
+# one on the orphan sweep, or two concurrent `coord notify` invocations) can
+# both see NULL and both post, producing the byte-identical duplicate-comment
+# incident on #2288 round 4 this closes. `coord.state.claim_review_post`
+# does the same conditional `INSERT ... OR IGNORE` + `rowcount` check
+# `claim_review_dispatch` already does for *dispatching* a review; the loser
+# of THIS claim skips *posting* it instead. Released
+# (`coord.state.release_review_post_claim`) only when the post attempt
+# itself fails, so a legitimate retry of a transient `gh`/GitHub failure
+# isn't permanently stranded — a successful post leaves the claim in place
+# forever, which is harmless since `review_posted_at` being set already
+# excludes the row from both callers' candidate queries.
+_DB_SCHEMA_VERSION = 22
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -1981,6 +2001,32 @@ _SCHEMA_SQL = """
             PRIMARY KEY (work_assignment_id, capability_partition)
         );
 
+        -- #2468: atomic review-POSTING claim — a sibling to `review_claims`
+        -- above, but for the act of posting a review's findings to GitHub
+        -- rather than dispatching the review worker. `_try_parse_and_post_
+        -- review` (the live completion path, in `coord.notify`) and
+        -- `post_orphaned_review_findings` (the orphan sweep, same module)
+        -- both query "done review assignments with `review_posted_at IS
+        -- NULL`" as their candidate set and only set `review_posted_at`
+        -- AFTER the GitHub post succeeds — a classic check-then-act gap.
+        -- Two coordinator passes racing each other (the #2468 incident: the
+        -- identical "Review Complete" comment posted twice, 4 seconds apart,
+        -- on #2288's round-4 review) each saw `review_posted_at IS NULL`
+        -- and both posted. `coord.state.claim_review_post` does a
+        -- conditional `INSERT ... OR IGNORE` keyed on `assignment_id` and
+        -- checks `rowcount` to learn atomically whether THIS call gets to
+        -- post; the loser skips instead of also posting a duplicate
+        -- comment. Released (`coord.state.release_review_post_claim`) only
+        -- when the post attempt itself fails, so a transient GitHub/`gh`
+        -- failure doesn't permanently strand the row unposted — a
+        -- successful post never releases the claim, which is harmless
+        -- because `review_posted_at` being set already excludes the row
+        -- from both callers' candidate queries from then on.
+        CREATE TABLE IF NOT EXISTS review_post_claims (
+            assignment_id TEXT    PRIMARY KEY,
+            claimed_at    REAL    NOT NULL
+        );
+
         CREATE INDEX IF NOT EXISTS idx_assignments_status ON assignments(status);
         CREATE INDEX IF NOT EXISTS idx_assignments_machine ON assignments(machine_name);
         -- #3470: the `issue-cost` report's full-history scan groups every

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/coord/notify.py

@@ -72,12 +72,14 @@ from coord.smoke import (
     smoke_leg_capabilities,
 )
 from coord.state import (
+    claim_review_post,
     load_dispatched,
     load_done_reviews_needing_post,
     load_liveness_audit_state,
     load_notified,
     mark_notified,
     mark_review_posted,
+    release_review_post_claim,
     save_liveness_audit_state,
     save_plan,
 )
@@ -3585,6 +3587,25 @@ def _try_parse_and_post_review(
         transition.assignment_id, findings.verdict, findings.body
     )
 
+    # #2468: claim the right to POST this review's findings before actually
+    # posting them. `post_orphaned_review_findings` (the orphan sweep) reads
+    # the identical "done review, review_posted_at IS NULL" candidate set
+    # this function is reacting to, and used to race it: both callers could
+    # see NULL and both post the byte-identical comment (the #2288 round-4
+    # incident this closes). Losing the claim means another caller is
+    # posting — or has already posted — these exact findings, so this call
+    # must NOT fall through to the "could not post" fallback comment below;
+    # return True (handled) rather than False (which the caller would read
+    # as a parse failure and post yet another, differently-worded, comment).
+    if not claim_review_post(transition.assignment_id):
+        log.info(
+            "#2468: lost the review-post claim for %s — another caller is "
+            "posting (or already posted) these findings; skipping to avoid "
+            "a duplicate GitHub comment",
+            transition.assignment_id,
+        )
+        return True
+
     review_target = record.get("review_target")
     repo_github = record["repo_github"]
 
@@ -3648,6 +3669,11 @@ def _try_parse_and_post_review(
         log.warning(
             "Failed to post review comment for %s: %s", transition.assignment_id, exc
         )
+        # #2468: both post attempts (gh pr review, then this issue-comment
+        # fallback) failed — release the claim so a later retry (another
+        # `coord notify` pass, or `post_orphaned_review_findings`) isn't
+        # permanently blocked from posting these findings at all.
+        release_review_post_claim(transition.assignment_id)
         return False
 
 
@@ -4546,6 +4572,24 @@ def post_orphaned_review_findings(
             # per-stage display can skip the HTTP fetch on later runs.
             _persist_review_findings(aid, findings.verdict, findings.body)
 
+            # #2468: claim the right to POST before actually posting —
+            # `_try_parse_and_post_review` (the live completion path, run
+            # from `detect_transitions` earlier in the same drain, or from a
+            # concurrent `coord notify` process) reads the identical
+            # "review_posted_at IS NULL" candidate set this sweep queried via
+            # `load_done_reviews_needing_post`. Losing the claim means that
+            # other caller is posting — or has already posted — these exact
+            # findings; skip entirely rather than writing a second,
+            # byte-identical GitHub comment (the #2288 round-4 incident).
+            if not claim_review_post(aid):
+                log.info(
+                    "post_orphaned: lost the review-post claim for %s — "
+                    "another caller is posting (or already posted) these "
+                    "findings; skipping",
+                    aid,
+                )
+                continue
+
             review_target = row.get("review_target")
             repo_github = row.get("repo_github") or ""
             issue_number = row.get("issue_number", 0)
@@ -4617,6 +4661,12 @@ def post_orphaned_review_findings(
                     mark_notified(aid, EVENT_COMPLETION)
                 posted_ids.append(aid)
                 log.info("post_orphaned: posted findings for review %s", aid)
+            else:
+                # #2468: both post attempts failed — release the claim so a
+                # later retry (the next drain's orphan sweep, or the live
+                # path) isn't permanently blocked from posting these
+                # findings at all.
+                release_review_post_claim(aid)
 
     return posted_ids
 

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/coord/serve_app.py

@@ -4175,6 +4175,67 @@ def openapi_spec() -> dict:
                 },
             }
         },
+        "/review-post-claim": {
+            "post": {
+                "summary": (
+                    "Atomically claim the right to POST a review's findings "
+                    "to GitHub (#2468) — a conditional insert so the live "
+                    "completion path and the orphan sweep can never both "
+                    "post the identical comment"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "assignment_id": {"type": "string"},
+                                },
+                                "required": ["assignment_id"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK — `claimed` is true iff this call won",
+                        "content": {"application/json": {"schema": ok_response}},
+                    },
+                    "400": {"description": "Missing assignment_id"},
+                },
+            }
+        },
+        "/review-post-claim-release": {
+            "post": {
+                "summary": (
+                    "Release a claim taken via /review-post-claim (#2468), "
+                    "ONLY when the post attempt itself failed, so a "
+                    "legitimate retry isn't permanently stranded"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "assignment_id": {"type": "string"},
+                                },
+                                "required": ["assignment_id"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK — idempotent, absent claim is a no-op",
+                        "content": {"application/json": {"schema": ok_response}},
+                    },
+                    "400": {"description": "Missing assignment_id"},
+                },
+            }
+        },
         "/smoke-claim": {
             "post": {
                 "summary": (
@@ -8408,6 +8469,44 @@ def build_app(
             )
         return JSONResponse({"ok": True})
 
+    async def post_review_post_claim(request: Request) -> Response:
+        # #2468: atomic review-POSTING claim on the daemon's canonical DB —
+        # see coord.state.claim_review_post's docstring for the duplicate-
+        # comment race this closes.
+        from coord import state  # noqa: PLC0415
+
+        body = await _read_json(request)
+        if body is None:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+        try:
+            claimed = state._claim_review_post_local(body["assignment_id"])
+        except KeyError as e:
+            return JSONResponse({"error": f"missing field: {e}"}, status_code=400)
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "review-post-claim write failed", "detail": str(e)},
+                status_code=503,
+            )
+        return JSONResponse({"ok": True, "claimed": claimed})
+
+    async def post_review_post_claim_release(request: Request) -> Response:
+        # #2468: release a claim taken via post_review_post_claim above.
+        from coord import state  # noqa: PLC0415
+
+        body = await _read_json(request)
+        if body is None:
+            return JSONResponse({"error": "invalid JSON body"}, status_code=400)
+        try:
+            state._release_review_post_claim_local(body["assignment_id"])
+        except KeyError as e:
+            return JSONResponse({"error": f"missing field: {e}"}, status_code=400)
+        except Exception as e:  # noqa: BLE001
+            return JSONResponse(
+                {"error": "review-post-claim-release write failed", "detail": str(e)},
+                status_code=503,
+            )
+        return JSONResponse({"ok": True})
+
     async def post_smoke_claim(request: Request) -> Response:
         # #3333: atomic smoke fan-out dispatch claim on the daemon's
         # canonical DB — see coord.state.claim_smoke_dispatch's docstring
@@ -12003,6 +12102,11 @@ def build_app(
         Route("/review-findings", post_review_findings, methods=["POST"]),
         Route("/review-claim", post_review_claim, methods=["POST"]),
         Route("/review-claim-release", post_review_claim_release, methods=["POST"]),
+        Route("/review-post-claim", post_review_post_claim, methods=["POST"]),
+        Route(
+            "/review-post-claim-release", post_review_post_claim_release,
+            methods=["POST"],
+        ),
         Route("/smoke-claim", post_smoke_claim, methods=["POST"]),
         Route("/smoke-claim-release", post_smoke_claim_release, methods=["POST"]),
         Route("/smoke-fanout-merge", post_smoke_fanout_merge, methods=["POST"]),

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/coord/state.py

@@ -2871,6 +2871,161 @@ def release_review_claim_if_row_is_review(assignment_id: str) -> None:
         pass
 
 
+# ── Atomic review-POSTING claim (#2468) ──────────────────────────────────────
+
+
+def claim_review_post(assignment_id: str) -> bool:
+    """Atomically claim the right to POST a review's findings for
+    *assignment_id* (#2468).
+
+    Returns ``True`` when THIS call wins the claim (no other in-flight claim
+    exists for the same review assignment), ``False`` when another caller
+    already holds it — the caller should skip posting entirely rather than
+    also writing a duplicate comment.
+
+    ``coord.notify._try_parse_and_post_review`` (the live completion path)
+    and ``coord.notify.post_orphaned_review_findings`` (the orphan sweep)
+    both query "done review assignments with ``review_posted_at IS NULL``"
+    as their candidate set and only set ``review_posted_at`` AFTER the
+    GitHub post succeeds — a classic check-then-act gap. Two coordinator
+    passes racing each other (the #2468 incident: the identical "Review
+    Complete" comment posted twice, 4 seconds apart, on #2288's round-4
+    review) each saw ``review_posted_at IS NULL`` and both posted. This is
+    the DB-level conditional insert that closes the gap — a single
+    ``INSERT ... OR IGNORE`` is atomic even across two separate
+    processes/machines, mirroring :func:`claim_review_dispatch` exactly,
+    but for *posting* a review rather than *dispatching* one.
+
+    Routes to the daemon when ``board_service`` is configured (the claim
+    table lives on the shared canonical DB, same as ``assignments``), else
+    writes the local DB directly.
+
+    Released by :func:`release_review_post_claim` — call sites are both
+    posting functions above, ONLY on a failed post attempt, so a legitimate
+    retry of a transient GitHub/``gh`` failure is never permanently
+    stranded. A successful post never releases the claim: once
+    ``review_posted_at`` is set, the row is excluded from both callers'
+    candidate queries forever, so a lingering claim row is harmless.
+    """
+    if not assignment_id:
+        return True
+    svc = _board_service()
+    resp = _route_write(svc, "/review-post-claim", {"assignment_id": assignment_id})
+    if resp is not None:
+        return bool(resp.get("claimed", False))
+    return _claim_review_post_local(assignment_id)
+
+
+def _claim_review_post_local(assignment_id: str) -> bool:
+    """Local-DB write for :func:`claim_review_post`.
+
+    Called directly by the daemon endpoint so it never re-routes back over
+    HTTP — mirrors :func:`_claim_review_dispatch_local` exactly, including
+    its ``retry_on_locked`` + row-scoped :func:`coord.db.undo_pending_write`
+    treatment: a `database is locked` collision is absorbed rather than
+    raised straight out, and if the `INSERT OR IGNORE` applied but the
+    following `conn.commit()` raised, the closure undoes its own
+    just-inserted row before re-raising so a commit failure never leaves a
+    claim nobody actually won sitting on the shared connection for an
+    unrelated handler's next commit to durably persist (the vimcode#1086
+    incident :func:`_claim_review_dispatch_local`'s own docstring
+    describes, for the sibling table).
+    """
+
+    def _write() -> int:
+        conn = get_connection()
+        claimed_at = time.time()
+        inserted = 0
+        try:
+            cur = sql.insert_ignore(
+                conn, "review_post_claims", ["assignment_id", "claimed_at"],
+                (assignment_id, claimed_at),
+            )
+            inserted = cur.rowcount or 0
+            conn.commit()
+        except sql.driver_errors() as exc:  # #2784: was sqlite3.OperationalError only
+            if inserted:
+                undo_pending_write(
+                    conn, exc,
+                    undo=lambda: sql.execute(
+                        conn,
+                        "DELETE FROM review_post_claims "
+                        "WHERE assignment_id=? AND claimed_at=?",
+                        (assignment_id, claimed_at),
+                    ),
+                )
+            raise
+        return inserted
+
+    return retry_on_locked(_write) > 0
+
+
+def release_review_post_claim(assignment_id: str) -> None:
+    """Release a claim taken by :func:`claim_review_post`, when posting the
+    review's findings failed (#2468).
+
+    Idempotent — deleting an absent row is a no-op. Routes to the daemon
+    exactly like :func:`claim_review_post` does: a thin client that claimed
+    via the ``/review-post-claim`` POST above must release through the same
+    seam, or the claim it took on the daemon's canonical DB would never
+    actually clear.
+
+    Deliberately NOT called on a successful post — see
+    :func:`claim_review_post`'s docstring for why a lingering claim after
+    success is harmless.
+    """
+    if not assignment_id:
+        return
+    svc = _board_service()
+    resp = _route_write(
+        svc, "/review-post-claim-release", {"assignment_id": assignment_id}
+    )
+    if resp is not None:
+        return
+    _release_review_post_claim_local(assignment_id)
+
+
+def _release_review_post_claim_local(assignment_id: str) -> None:
+    """Local-DB write for :func:`release_review_post_claim`.
+
+    Called directly by the daemon endpoint so it never re-routes back over
+    HTTP. Same ``retry_on_locked`` + undo-this-row-on-commit-failure
+    treatment as :func:`_release_review_dispatch_claim_local` — see that
+    function's docstring for why the undo is a compensating statement
+    rather than any transaction-level rollback.
+    """
+
+    def _write() -> None:
+        conn = get_connection()
+        row = sql.execute(
+            conn,
+            "SELECT claimed_at FROM review_post_claims WHERE assignment_id=?",
+            (assignment_id,),
+        ).fetchone()
+        claimed_at = row[0] if row is not None else None
+        deleted = 0
+        try:
+            cur = sql.execute(
+                conn,
+                "DELETE FROM review_post_claims WHERE assignment_id=?",
+                (assignment_id,),
+            )
+            deleted = cur.rowcount or 0
+            conn.commit()
+        except sql.driver_errors() as exc:  # #2784: was sqlite3.OperationalError only
+            if deleted and claimed_at is not None:
+                undo_pending_write(
+                    conn, exc,
+                    undo=lambda: sql.insert_ignore(
+                        conn, "review_post_claims", ["assignment_id", "claimed_at"],
+                        (assignment_id, claimed_at),
+                    ),
+                )
+            raise
+
+    retry_on_locked(_write)
+
+
 # ── Atomic smoke fan-out dispatch claim (#3333) ──────────────────────────────
 
 

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/tests/test_db.py

@@ -2472,7 +2472,14 @@ class TestUatStateAndReasonColumns:
 # #3470 bumped this to (21, 98): two new `assignments` indexes appended to
 # `_SCHEMA_SQL` (not a column — `_MIGRATE_ADD_COLUMNS`'s length is
 # unchanged), for the `issue-cost` report's full-history scan.
-_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (21, 98)
+# #2468 bumped this to (22, 98): a new `review_post_claims` TABLE (not a
+# column — `_MIGRATE_ADD_COLUMNS`'s length is unchanged at 98, so only the
+# version moved, to force `_ensure_schema`'s `CREATE TABLE IF NOT EXISTS` to
+# run once more on an existing database) — same shape as #3113's
+# `review_claims` / #3333's `smoke_claims` bumps above. Closes the race where
+# the live review-completion path and the orphan sweep both see
+# `review_posted_at IS NULL` and both post the identical GitHub comment.
+_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (22, 98)
 
 
 class TestMigrateAddColumnsVersionGuard:

{code_coordinator-0.5.562 → code_coordinator-0.5.563}/tests/test_notify.py

@@ -1360,6 +1360,119 @@ class TestPostOrphanedReviewFindings:
         assert body_arg.startswith("<!-- coord:review verdict=approve")
         assert "All clear." in body_arg
 
+
+class TestReviewPostClaimRace:
+    """#2468: the identical "Review Complete" comment posted twice, 4 seconds
+    apart, on #2288's round-4 review. `_try_parse_and_post_review` (the live
+    completion path) and `post_orphaned_review_findings` (the orphan sweep)
+    both query "done review, `review_posted_at IS NULL`" and only set
+    `review_posted_at` AFTER posting — a classic check-then-act gap when two
+    coordinator passes race each other. These tests simulate the race by
+    having one caller win `claim_review_post` out-of-band (standing in for a
+    concurrent process) immediately before the other caller runs, and assert
+    the loser never posts."""
+
+    def test_orphan_sweep_skips_when_live_path_already_claimed(
+        self, coord_dir: Path, config: Config, tmp_path: Path
+    ) -> None:
+        """Live-path's claim wins first (simulating `_try_parse_and_post_
+        review` mid-flight on another process, `review_posted_at` not yet
+        set) — the orphan sweep must see the row as a candidate
+        (`review_posted_at IS NULL`) but skip posting rather than writing a
+        second, byte-identical comment."""
+        _record_review_assignment("orphan-race1", review_target="50")
+        from coord.db import get_connection
+        conn = get_connection()
+        conn.execute(
+            "UPDATE assignments SET status='done', finished_at=1234.0 "
+            "WHERE assignment_id='orphan-race1'"
+        )
+        conn.commit()
+
+        # Simulates the live completion path having already won the claim
+        # on a concurrent process, before this sweep runs.
+        assert state_mod.claim_review_post("orphan-race1") is True
+
+        log_path = _make_log_with_review(tmp_path, "request-changes", "Blocking finding.")
+        agent_status = {
+            "active": [],
+            "completed": [_agent_completed("orphan-race1", "done", log_path=log_path)],
+        }
+        with patch.object(notify_mod, "_agent_status", return_value=agent_status), \
+             patch("coord.notify.github_ops.post_pr_review") as mock_review, \
+             patch("coord.notify.github_ops.post_issue_comment") as mock_comment:
+            posted = notify_mod.post_orphaned_review_findings(config)
+
+        assert posted == []
+        mock_review.assert_not_called()
+        mock_comment.assert_not_called()
+
+    def test_live_path_treats_lost_claim_as_handled_not_a_parse_failure(
+        self, coord_dir: Path, config: Config, tmp_path: Path
+    ) -> None:
+        """Orphan sweep's claim wins first (simulating a concurrent
+        `post_orphaned_review_findings` pass) — `_try_parse_and_post_review`
+        must return True (handled elsewhere) rather than False, which the
+        caller in `post_transition` would read as a parse failure and post
+        yet another, differently-worded fallback comment."""
+        _record_review_assignment("rev-race2", review_target="99")
+        log_path = _make_log_with_review(tmp_path, "request-changes", "Blocking finding.")
+
+        # Simulates a concurrent orphan-sweep pass having already won the
+        # claim for this same assignment.
+        assert state_mod.claim_review_post("rev-race2") is True
+
+        transition = notify_mod.Transition(
+            assignment_id="rev-race2",
+            machine_name="laptop",
+            repo_name="api",
+            issue_number=42,
+            event="completion",
+            exit_code=0,
+        )
+        record = {"review_target": "99", "repo_github": "acme/api"}
+        entry = {"log_path": log_path}
+        with patch("coord.notify.github_ops.post_pr_review") as mock_review, \
+             patch("coord.notify.github_ops.post_issue_comment") as mock_comment:
+            result = notify_mod._try_parse_and_post_review(
+                transition, record, entry, 1.0,
+            )
+
+        assert result is True
+        mock_review.assert_not_called()
+        mock_comment.assert_not_called()
+
+    def test_duplicate_direct_calls_post_exactly_once(
+        self, coord_dir: Path, config: Config, tmp_path: Path
+    ) -> None:
+        """Two back-to-back calls to `_try_parse_and_post_review` for the
+        SAME assignment — standing in for two coordinator passes racing each
+        other on the live completion path itself — must post exactly once."""
+        _record_review_assignment("rev-race3", review_target="101")
+        log_path = _make_log_with_review(tmp_path, "approve", "LGTM.")
+
+        transition = notify_mod.Transition(
+            assignment_id="rev-race3",
+            machine_name="laptop",
+            repo_name="api",
+            issue_number=42,
+            event="completion",
+            exit_code=0,
+        )
+        record = {"review_target": "101", "repo_github": "acme/api"}
+        entry = {"log_path": log_path}
+        with patch("coord.notify.github_ops.post_pr_review") as mock_review:
+            first = notify_mod._try_parse_and_post_review(
+                transition, record, entry, 1.0,
+            )
+            second = notify_mod._try_parse_and_post_review(
+                transition, record, entry, 1.0,
+            )
+
+        assert first is True
+        assert second is True  # loser: treated as handled, not re-posted
+        mock_review.assert_called_once()
+
     # ── #2476: cost/token capture on the orphaned-findings path ────────────
     #
     # Root cause: `post_orphaned_review_findings` (run_drain's step 4, which