code-coordinator 0.5.187__tar.gz → 0.5.189__tar.gz

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.187",
+  "tag": "0.5.189",
   "distance": 0,
-  "node": "gc74dfc5a8d399b33526076eaec24aed5d5ad1ce3",
+  "node": "g9c81a5128ae2355b8dee8b005e2836f58e553167",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/agent.py

@@ -3678,6 +3678,49 @@ NEW_ISSUE_CHAT_DENY_COMMANDS: list[str] = [
 ]
 
 
+# Deny list applied to review workers (#2461). Unlike every other member of
+# WRITE_CAPABLE_SPEC_TYPES, a reviewer has ZERO legitimate mutations of its
+# own — coord.review.REVIEWER_SYSTEM_PROMPT already tells it "You are NOT
+# allowed to push commits or modify the PR's code. You only review" and "You
+# are NOT allowed to run any `gh` commands" (the coordinator posts the
+# review on its behalf after the session ends). Before #2461 that was
+# enforced by the PROMPT ALONE: `"review"` wasn't one of the explicit
+# branches in `default_worker_command`, so it fell through to the generic
+# `else` below and got the exact same `Read,Edit,Write,Bash,Monitor` grant as
+# a real work leg — nothing but the model's own good behaviour stood between
+# "read the diff" and "silently commit a fix and push it". This list is
+# wired into BOTH the system prompt (via `build_deny_prompt`, soft — a
+# reminder) AND `--disallowedTools` (CLI-enforced, hard — see the
+# `spec.type == "review"` branch below) so a reviewer that ignores its own
+# prompt still cannot shell out to a mutating git/gh command. The read-only
+# git the briefing actually tells reviewers to run (`git fetch`, `git diff`,
+# `git log`) stays allowed by omission.
+REVIEW_DENY_COMMANDS: list[str] = [
+    "Bash(gh *)",
+    "Bash(git push *)",
+    "Bash(git commit *)",
+    "Bash(git add *)",
+    "Bash(git merge *)",
+    "Bash(git rebase *)",
+    "Bash(git cherry-pick *)",
+    "Bash(git reset *)",
+    "Bash(git checkout *)",
+    "Bash(git switch *)",
+    "Bash(git branch *)",
+    "Bash(git stash *)",
+    "Bash(git clean *)",
+    "Bash(git rm *)",
+    "Bash(git apply *)",
+    "Bash(git am *)",
+    "Bash(git tag *)",
+    "Bash(rm -rf *)",
+    "Bash(rm -fr *)",
+    "Bash(coord approve *)",
+    "Bash(coord merge *)",
+    "Bash(coord assign *)",
+]
+
+
 WorkerCommandBuilder = Callable[[AssignmentSpec], list[str]]
 
 
@@ -4111,6 +4154,26 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         system_prompt = spec.system_prompt if spec.system_prompt else SMOKE_SYSTEM_PROMPT
         system_prompt += build_deny_prompt(spec.deny_commands)
         allowed_tools = "Read,Bash"
+    elif spec.type == "review":
+        # #2461: give review its own branch instead of falling through to
+        # the generic `else` below — see REVIEW_DENY_COMMANDS for the full
+        # story. A reviewer reads the diff and reports a verdict; it edits
+        # and pushes nothing, so it gets no Edit/Write. `Monitor` is
+        # withheld too, for the same #1394/#2301 reason the `smoke` branch
+        # above withholds it: a review leg is a one-shot `claude -p`
+        # session, and an await-a-notification tool that only resumes an
+        # INTERACTIVE session would silently kill it mid-run.
+        #
+        # A scratch/tmp path outside the worktree (e.g. `/tmp/...`) stays
+        # writable for a reviewer that wants to stage its findings before
+        # the final `coord report-result --body-file` call — Bash retains
+        # ordinary shell redirection (`cat >`, heredocs) even with no Write
+        # tool grant; only the Edit/Write *tools* (which target the
+        # worktree/repo) and the mutating git/gh commands below are blocked.
+        from coord.review import REVIEWER_SYSTEM_PROMPT  # noqa: PLC0415
+        system_prompt = spec.system_prompt if spec.system_prompt else REVIEWER_SYSTEM_PROMPT
+        system_prompt += build_deny_prompt(REVIEW_DENY_COMMANDS)
+        allowed_tools = "Read,Bash"
     else:
         system_prompt = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
         system_prompt += build_deny_prompt(spec.deny_commands)
@@ -4177,6 +4240,14 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         for pattern in _base_checkout_write_guard_tools(spec.repo_path):
             if pattern not in disallowed_tools:
                 disallowed_tools.append(pattern)
+    # #2461: review gets its mutating-command deny list wired into
+    # --disallowedTools too, not just the soft system-prompt reminder from
+    # build_deny_prompt above — the CLI enforces this one even if the model
+    # decides to ignore its own prompt.
+    if spec.type == "review":
+        for pattern in REVIEW_DENY_COMMANDS:
+            if pattern not in disallowed_tools:
+                disallowed_tools.append(pattern)
     if disallowed_tools:
         argv.extend(["--disallowedTools", ",".join(disallowed_tools)])
     # #315: when resuming a prior chat session, load the prior conversation so

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/cli.py

@@ -91,6 +91,7 @@ from coord.notifier.cli import notifier_group
 # client, coord/commands/portal.py is the CLI over it.
 from coord.commands.portal import portal_group
 from coord.commands.merge import (
+    backfill_review_cost,
     bounce,
     merge,
     post_pending_reviews,
@@ -442,6 +443,7 @@ main.add_command(unqueue)
 main.add_command(set_test_mode)
 main.add_command(notify)
 main.add_command(post_pending_reviews)
+main.add_command(backfill_review_cost)
 main.add_command(merge)
 main.add_command(resume)
 main.add_command(test)

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/commands/merge.py

@@ -883,6 +883,85 @@ def post_pending_reviews(config_path: Path, repo_name: str | None) -> None:
             )
 
 
+@click.command(
+    "backfill-review-cost",
+    help=(
+        "One-shot repair for #2476: capture cost/tokens for review "
+        "assignments left at cost_usd IS NULL/0 by the review-completion "
+        "capture gap (post_orphaned_review_findings recovered the verdict "
+        "but never captured cost/tokens — fixed going forward, this repairs "
+        "the backlog it already created).\n\n"
+        "Walks every terminal type='review' row with cost_usd IS NULL or 0, "
+        "tries the local log first, then the assignment's agent /logs/<id> "
+        "endpoint, parses, and persists via the same "
+        "update_assignment_cost/update_assignment_tokens writers the live "
+        "capture path uses — no new write mechanism. Run once per machine "
+        "that hosts review logs; logs that have already aged out (or "
+        "whose agent is offline) are reported as still-missing rather than "
+        "silently dropped, so the residual gap stays known."
+    ),
+)
+@_CONFIG_OPTION
+@click.option("--repo", "repo_name", default=None, help="Only process assignments for this repo.")
+def backfill_review_cost(config_path: Path, repo_name: str | None) -> None:
+    from coord.notify import _capture_cost_and_tokens_for_review
+    from coord.state import load_review_assignments_missing_cost
+    from coord.usage import LOGS_DIR
+
+    cfg = _load_config(config_path)
+    machines_by_name = {m.name: m for m in cfg.machines}
+
+    candidates = load_review_assignments_missing_cost(repo_name=repo_name)
+    if not candidates:
+        click.echo("No review assignments with missing cost/tokens found.")
+        return
+
+    click.echo(f"Found {len(candidates)} review assignment(s) with missing cost/tokens:")
+    for row in candidates:
+        click.echo(
+            f"  {row['assignment_id']} — {row['repo_name']} #{row['issue_number']} "
+            f"(machine: {row['machine_name']})"
+        )
+
+    recovered: list[dict] = []
+    still_missing: list[dict] = []
+    for row in candidates:
+        aid = row["assignment_id"]
+        machine = machines_by_name.get(row["machine_name"])
+        host = machine.host if machine is not None else None
+        # #2476: always offer the conventional local path — it resolves
+        # correctly whenever this command runs on the same box that hosted
+        # the review (the common case for a per-machine repair run), and is
+        # a harmless miss otherwise (falls straight through to the *host*
+        # fetch below, same as `_capture_cost_and_tokens_for_review` already
+        # does for every other caller).
+        log_path = str(LOGS_DIR / f"{aid}.log")
+        wrote = _capture_cost_and_tokens_for_review(
+            aid, log_path=log_path, host=host,
+            provider_name=row.get("provider_name"),
+        )
+        (recovered if wrote else still_missing).append(row)
+
+    click.echo(f"\nRecovered cost/tokens for {len(recovered)} assignment(s):")
+    for row in recovered:
+        click.echo(f"  {row['assignment_id']} — {row['repo_name']} #{row['issue_number']}")
+
+    if still_missing:
+        click.echo(
+            f"\n{len(still_missing)} assignment(s) still missing "
+            "(log gone on disk and agent unreachable/offline):"
+        )
+        for row in still_missing:
+            click.echo(
+                f"  {row['assignment_id']} — {row['repo_name']} #{row['issue_number']} "
+                f"(machine: {row['machine_name']})"
+            )
+    click.echo(
+        f"\nSummary: {len(recovered)} recovered, {len(still_missing)} still missing "
+        f"of {len(candidates)} total."
+    )
+
+
 def _load_issue_states() -> tuple[dict[str, set[int]], dict[str, set[int]]]:
     """Return ``(open_by_repo, known_by_repo)``.
 

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/notify.py

@@ -2133,28 +2133,26 @@ def _persist_review_findings(assignment_id: str, verdict: str, body: str) -> Non
         )
 
 
-def _fetch_raw_log_text(transition: Transition, entry: dict) -> str | None:
-    """Best-effort raw log text for #1956/#1348 diagnostics.
+def _fetch_raw_log_text_by_id(
+    assignment_id: str, log_path: str | None, host: str | None,
+) -> str | None:
+    """Shared local-file-then-agent-fetch raw-text primitive.
 
-    Mirrors the local-file-then-agent-fetch fallback :func:`_try_parse_and_post_review`
-    itself uses to PARSE the log, but returns the raw text instead — the
-    diagnostic detectors (:func:`coord.review.detect_end_review_without_verdict`,
-    :func:`coord.review.detect_unparsed_review_marker`) need the text the
-    strict parser already rejected, not another parse attempt. Returns
-    ``None`` on any I/O failure — diagnostics are best-effort by design and
-    must never be the reason ``coord notify`` raises.
+    Tries *log_path* on the local filesystem first (cheap, no network); when
+    that's absent or unreadable (the worker ran on a remote agent whose log
+    isn't on this filesystem), falls back to fetching it via the agent's
+    ``/logs/<id>`` endpoint at *host*. Returns ``None`` when neither source
+    yields text — every caller here is best-effort by design.
     """
-    log_path = entry.get("log_path")
     if log_path:
         try:
             return Path(log_path).read_text(encoding="utf-8", errors="replace")
         except OSError:
             pass
-    host = _agent_host(transition.machine_name)
     if host:
         try:
             resp = httpx.get(
-                f"http://{host}:{AGENT_PORT}/logs/{transition.assignment_id}",
+                f"http://{host}:{AGENT_PORT}/logs/{assignment_id}",
                 timeout=15.0,
             )
             resp.raise_for_status()
@@ -2164,6 +2162,126 @@ def _fetch_raw_log_text(transition: Transition, entry: dict) -> str | None:
     return None
 
 
+def _fetch_raw_log_text(transition: Transition, entry: dict) -> str | None:
+    """Best-effort raw log text for #1956/#1348 diagnostics.
+
+    Mirrors the local-file-then-agent-fetch fallback :func:`_try_parse_and_post_review`
+    itself uses to PARSE the log, but returns the raw text instead — the
+    diagnostic detectors (:func:`coord.review.detect_end_review_without_verdict`,
+    :func:`coord.review.detect_unparsed_review_marker`) need the text the
+    strict parser already rejected, not another parse attempt. Returns
+    ``None`` on any I/O failure — diagnostics are best-effort by design and
+    must never be the reason ``coord notify`` raises.
+    """
+    log_path = entry.get("log_path")
+    host = _agent_host(transition.machine_name)
+    return _fetch_raw_log_text_by_id(transition.assignment_id, log_path, host)
+
+
+def _capture_cost_and_tokens_for_review(
+    assignment_id: str,
+    *,
+    log_path: str | None,
+    host: str | None,
+    provider_name: str | None = None,
+) -> bool:
+    """#2476: best-effort cost/token capture for a review row, local-log-
+    first with a remote-agent-fetch fallback.
+
+    ``post_transition``'s ``_capture_cost`` is the ONLY place cost/tokens get
+    captured for a review that completes through the direct
+    ``detect_transitions`` path — but investigation of #2476 found the
+    majority of review completions actually get their GitHub comment posted
+    later, by :func:`post_orphaned_review_findings` (run_drain's step 4,
+    which runs on every ~60s drain tick, not just as manual cleanup): that
+    function does its own independent ``/status`` poll and local-then-remote
+    log fallback to recover the VERDICT, but until now never captured
+    cost/tokens at all. Once that row is marked ``notified``/
+    ``review_posted_at``, nothing ever revisits it — so a review rescued by
+    the orphaned-findings path was permanently stuck at ``cost_usd IS NULL``
+    even though the exact same log :func:`post_orphaned_review_findings`
+    just successfully parsed the verdict from also has a perfectly good
+    ``total_cost_usd`` in it.
+
+    Mirrors :func:`_capture_cost`'s log-parse-then-persist logic (same
+    :func:`coord.usage.parse_usage_from_log`, same
+    ``update_assignment_cost``/``update_assignment_tokens`` writers) so this
+    is not a new capture mechanism — just the existing one, reachable from a
+    second call site. Never raises; returns True iff something was
+    persisted.
+    """
+    from coord.state import update_assignment_cost, update_assignment_tokens  # noqa: PLC0415
+    from coord.usage import parse_usage_from_log  # noqa: PLC0415
+
+    parsed = None
+    if log_path:
+        try:
+            parsed = parse_usage_from_log(Path(log_path), provider_name=provider_name)
+        except Exception as exc:  # noqa: BLE001
+            log.debug(
+                "_capture_cost_and_tokens_for_review: local parse failed for %s: %s",
+                assignment_id, exc,
+            )
+            parsed = None
+
+    if parsed is None and host:
+        text = _fetch_raw_log_text_by_id(assignment_id, None, host)
+        if text:
+            import tempfile  # noqa: PLC0415
+
+            try:
+                with tempfile.NamedTemporaryFile(
+                    mode="w", suffix=".log", delete=True
+                ) as tf:
+                    tf.write(text)
+                    tf.flush()
+                    parsed = parse_usage_from_log(
+                        Path(tf.name), provider_name=provider_name
+                    )
+            except Exception as exc:  # noqa: BLE001
+                log.debug(
+                    "_capture_cost_and_tokens_for_review: remote parse failed "
+                    "for %s: %s", assignment_id, exc,
+                )
+                parsed = None
+
+    if parsed is None:
+        return False
+
+    wrote = False
+    if parsed.total_cost_usd and parsed.total_cost_usd > 0:
+        try:
+            update_assignment_cost(assignment_id, parsed.total_cost_usd)
+            wrote = True
+        except Exception as exc:  # noqa: BLE001
+            log.warning(
+                "_capture_cost_and_tokens_for_review: failed to persist cost "
+                "for %s: %s", assignment_id, exc,
+            )
+
+    token_total = (
+        parsed.input_tokens + parsed.output_tokens
+        + parsed.cache_creation_tokens + parsed.cache_read_tokens
+    )
+    if token_total > 0:
+        try:
+            update_assignment_tokens(
+                assignment_id,
+                input_tokens=parsed.input_tokens,
+                output_tokens=parsed.output_tokens,
+                cache_creation_tokens=parsed.cache_creation_tokens,
+                cache_read_tokens=parsed.cache_read_tokens,
+            )
+            wrote = True
+        except Exception as exc:  # noqa: BLE001
+            log.warning(
+                "_capture_cost_and_tokens_for_review: failed to persist "
+                "tokens for %s: %s", assignment_id, exc,
+            )
+
+    return wrote
+
+
 def _warn_missing_review_verdict(
     transition: Transition, entry: dict, diagnostic: list,
 ) -> None:
@@ -2838,6 +2956,20 @@ def post_orphaned_review_findings(
         for row in rows:
             aid = row["assignment_id"]
             log_path = log_by_id.get(aid)
+
+            # #2476: capture cost/tokens for this row too. This is the ONLY
+            # place a review whose verdict is being recovered here (rather
+            # than through the direct detect_transitions → post_transition
+            # path, which already calls `_capture_cost`) ever gets a chance
+            # at cost/token capture — once `posted`/`mark_notified` below
+            # lands, nothing ever revisits this row. Independent of whether
+            # findings parsing succeeds: a row whose body can't be recovered
+            # can still have its cost recovered from the same log.
+            _capture_cost_and_tokens_for_review(
+                aid, log_path=log_path, host=machine.host,
+                provider_name=row.get("provider_name"),
+            )
+
             findings = None
             # Try local file first (cheap) — works when notify runs on the
             # same host as the agent. Falls back to fetching via HTTP so the

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/providers/claude.py

@@ -113,6 +113,7 @@ class ClaudeProvider(Provider):
             NEW_ISSUE_CHAT_DENY_COMMANDS,
             NEW_ISSUE_CHAT_SYSTEM_PROMPT,
             REFINEMENT_SYSTEM_PROMPT,
+            REVIEW_DENY_COMMANDS,
             TEST_CHAT_SYSTEM_PROMPT,
             WORKER_PLAN_PROMPT,
             WORKER_SYSTEM_PROMPT,
@@ -120,6 +121,7 @@ class ClaudeProvider(Provider):
             _sealed_write_guard_tools,
             build_deny_prompt,
         )
+        from coord.review import REVIEWER_SYSTEM_PROMPT  # noqa: PLC0415
         from coord.smoke import SMOKE_SYSTEM_PROMPT  # noqa: PLC0415
 
         binary = self._binary if self._binary is not None else DEFAULT_WORKER_BINARY
@@ -180,6 +182,17 @@ class ClaudeProvider(Provider):
                 _sp = spec.system_prompt if spec.system_prompt else SMOKE_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
                 _at = "Read,Bash"
+            elif spec.type == "review":
+                # #2461: keep in sync with default_worker_command's identical
+                # branch — a reviewer reads the diff and reports a verdict,
+                # it edits and pushes nothing, so Read,Bash only (no
+                # Edit/Write, no Monitor — same one-shot-session reasoning as
+                # the `smoke` branch above). See REVIEW_DENY_COMMANDS for why
+                # its mutating-command deny list also lands in
+                # --disallowedTools below, not just this prompt text.
+                _sp = spec.system_prompt if spec.system_prompt else REVIEWER_SYSTEM_PROMPT
+                _sp += build_deny_prompt(REVIEW_DENY_COMMANDS)
+                _at = "Read,Bash"
             else:
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
@@ -217,6 +230,12 @@ class ClaudeProvider(Provider):
             for pattern in _base_checkout_write_guard_tools(spec.repo_path):
                 if pattern not in disallowed_tools:
                     disallowed_tools.append(pattern)
+        # #2461: same CLI-enforced hard block as default_worker_command —
+        # see REVIEW_DENY_COMMANDS.
+        if spec.type == "review":
+            for pattern in REVIEW_DENY_COMMANDS:
+                if pattern not in disallowed_tools:
+                    disallowed_tools.append(pattern)
         if disallowed_tools:
             argv.extend(["--disallowedTools", ",".join(disallowed_tools)])
         if spec.resume_session_id:

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/providers/claude_pty.py

@@ -433,6 +433,7 @@ class ClaudePtyProvider(Provider):
             NEW_ISSUE_CHAT_DENY_COMMANDS,
             NEW_ISSUE_CHAT_SYSTEM_PROMPT,
             REFINEMENT_SYSTEM_PROMPT,
+            REVIEW_DENY_COMMANDS,
             TEST_CHAT_SYSTEM_PROMPT,
             WORKER_PLAN_PROMPT,
             WORKER_SYSTEM_PROMPT,
@@ -497,6 +498,16 @@ class ClaudePtyProvider(Provider):
                 _sp = spec.system_prompt if spec.system_prompt else SMOKE_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
                 _at = "Read,Bash"
+            elif spec.type == "review":
+                # #2461: keep in sync with default_worker_command's identical
+                # branch — a reviewer reads the diff and reports a verdict,
+                # it edits and pushes nothing, so Read,Bash only (no
+                # Edit/Write, no Monitor — same one-shot-session reasoning as
+                # the `smoke` branch above).
+                from coord.review import REVIEWER_SYSTEM_PROMPT  # noqa: PLC0415
+                _sp = spec.system_prompt if spec.system_prompt else REVIEWER_SYSTEM_PROMPT
+                _sp += build_deny_prompt(REVIEW_DENY_COMMANDS)
+                _at = "Read,Bash"
             else:
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)

{code_coordinator-0.5.187 → code_coordinator-0.5.189}/coord/state.py

@@ -3248,6 +3248,13 @@ def load_done_reviews_needing_post(repo_name: str | None = None) -> list[dict]:
                         "review_of_assignment_id": a.get("review_of_assignment_id"),
                         "review_target": a.get("review_target"),
                         "status": a.get("status"),
+                        # #2476: threaded through to
+                        # coord.notify._capture_cost_and_tokens_for_review so
+                        # post_orphaned_review_findings' cost/token capture
+                        # resolves the right Provider instead of always
+                        # assuming claude (mirrors the #1710 provider_name
+                        # threading everywhere else cost is parsed).
+                        "provider_name": a.get("provider_name"),
                     })
             return results
         except Exception:  # noqa: BLE001 — daemon unreachable → local fallback
@@ -3277,6 +3284,80 @@ def _load_done_reviews_needing_post_local(repo_name: str | None = None) -> list[
     return [_row_to_dispatched_dict(row) for row in rows]
 
 
+def load_review_assignments_missing_cost(repo_name: str | None = None) -> list[dict]:
+    """#2476: return terminal review assignments whose cost was never
+    captured (``cost_usd IS NULL OR cost_usd = 0``).
+
+    Feeds ``coord backfill-review-cost`` — the one-shot repair for the
+    already-lost data the #2476 capture gap left behind. Unlike
+    :func:`load_done_reviews_needing_post` this is NOT scoped to
+    ``status='done'``/``review_posted_at IS NULL`` — a review can be
+    terminal (``done``/``failed``/``advisory``) with a perfectly good
+    verdict already posted and STILL be missing cost, since the capture gap
+    is independent of whether the findings post succeeded. Excludes
+    ``running``/``pending``/``finalizing`` rows: a still-in-flight or
+    not-yet-promoted review has no final cost to recover yet — the live
+    capture path (or a later backfill run) is the right place for those,
+    not a one-shot repair racing an in-progress worker.
+
+    Optionally filtered to a single repo by *repo_name*. Returns dicts in
+    the same shape as :func:`load_done_reviews_needing_post` (including
+    ``provider_name`` for :func:`coord.notify._capture_cost_and_tokens_for_review`).
+
+    **Daemon-aware:** mirrors :func:`load_done_reviews_needing_post` — reads
+    the ``GET /board`` payload when a ``board_service`` is configured so a
+    thin client sees the real candidates instead of an empty local table.
+    """
+    svc = _board_service()
+    if svc is not None:
+        try:
+            from coord.client import fetch_board_payload  # noqa: PLC0415
+
+            payload = fetch_board_payload(svc)
+            results: list[dict] = []
+            for a in payload.get("assignments", []):
+                if (
+                    a.get("type") == "review"
+                    and a.get("status") not in ("running", "pending", "finalizing")
+                    and not (a.get("cost_usd") or 0)
+                    and (repo_name is None or a.get("repo_name") == repo_name)
+                ):
+                    results.append({
+                        "assignment_id": a.get("assignment_id"),
+                        "machine_name": a.get("machine_name", ""),
+                        "repo_name": a.get("repo_name", ""),
+                        "repo_github": a.get("repo_github"),
+                        "issue_number": a.get("issue_number", 0),
+                        "issue_title": a.get("issue_title", ""),
+                        "status": a.get("status"),
+                        "provider_name": a.get("provider_name"),
+                    })
+            return results
+        except Exception:  # noqa: BLE001 — daemon unreachable → local fallback
+            pass
+    return _load_review_assignments_missing_cost_local(repo_name=repo_name)
+
+
+def _load_review_assignments_missing_cost_local(repo_name: str | None = None) -> list[dict]:
+    """Local-DB read for :func:`load_review_assignments_missing_cost`."""
+    conn = get_connection()
+    where = (
+        "type='review' AND status NOT IN ('running', 'pending', 'finalizing') "
+        "AND (cost_usd IS NULL OR cost_usd = 0)"
+    )
+    if repo_name:
+        rows = conn.execute(
+            f"SELECT * FROM assignments WHERE {where} AND repo_name=? "
+            "ORDER BY finished_at",
+            (repo_name,),
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            f"SELECT * FROM assignments WHERE {where} ORDER BY finished_at",
+        ).fetchall()
+    return [_row_to_dispatched_dict(row) for row in rows]
+
+
 # ── Plan persistence ────────────────────────────────────────────────────────────
 
 def save_plan(assignment_id: str, plan_dict: dict) -> None: