code-coordinator 0.5.186__tar.gz → 0.5.188__tar.gz

{code_coordinator-0.5.186 → code_coordinator-0.5.188}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.186",
+  "tag": "0.5.188",
   "distance": 0,
-  "node": "g91a8fc0c07fd891a6a9c258c7f30aba6e090c865",
+  "node": "ge96703c949bd613e9a8c2b576d71050e015f956e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.186 → code_coordinator-0.5.188}/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.186 → code_coordinator-0.5.188}/coord/commands/merge.py

@@ -456,7 +456,9 @@ def _dispatch_conflict_fixes(events, config, *, dry_run: bool) -> None:
             # failed for this entry in this session, don't loop — mark
             # HUMAN_REQUIRED so the user takes over.  A successful
             # prior fix does not trigger this guard (#784).
-            if has_prior_conflict_fix(fix_board, ev.entry.assignment_id):
+            if has_prior_conflict_fix(
+                fix_board, ev.entry.assignment_id, current_error=ev.entry.error,
+            ):
                 ev.entry.state = HUMAN_REQUIRED
                 click.echo(
                     f"  {ev.entry.repo_name} #{ev.entry.issue_number}: "
@@ -881,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.186 → code_coordinator-0.5.188}/coord/conflict_fix.py

@@ -367,7 +367,32 @@ def _has_active_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
     )
 
 
-def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
+def _dispatched_error(assignment: Assignment) -> str | None:
+    """The merge-failure text *assignment*'s briefing was built from.
+
+    ``build_conflict_fix_briefing``/``build_semantic_conflict_briefing``
+    both embed the triggering ``QueuedMerge.error`` verbatim (as a
+    ``"Reason: …"``/``"Last merge error: …"`` line) — that's the only durable
+    record of what the merge looked like *at dispatch time*, since
+    ``on_conflict_fix_done`` clears ``entry.error`` back to ``None`` on
+    success before the merge is retried. Returns ``None`` when the briefing
+    doesn't carry either marker (e.g. a hand-built test ``Assignment``).
+    """
+    briefing = assignment.briefing or ""
+    for line in briefing.splitlines():
+        if line.startswith("Reason: "):
+            return line[len("Reason: "):]
+        if line.startswith("Last merge error: "):
+            return line[len("Last merge error: "):]
+    return None
+
+
+def has_prior_conflict_fix(
+    board: Board,
+    merge_entry_id: str | None,
+    *,
+    current_error: str | None = None,
+) -> bool:
     """True when a second conflict-fix dispatch for *merge_entry_id* is blocked.
 
     Blocks when a conflict-fix is **active** (running/pending — don't spawn a
@@ -379,6 +404,18 @@ def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
     followed by a new conflict if other PRs merged in the meantime; that is a
     fresh situation and warrants a fresh fix attempt.  Only actual failures
     consume the one-per-entry cap.
+
+    #2475: that "successful" carve-out assumed a ``done`` conflict-fix always
+    resolved *something*. It doesn't when the merge was never blocked by a
+    content conflict in the first place (e.g. a permanently-unmergeable
+    branch-protection state) — the worker finds nothing to rebase, exits
+    ``done``, and the merge queue retries into the *identical* failure
+    forever (#2009's 38-turn thrash). When *current_error* is given and a
+    prior ``done`` conflict-fix's dispatch-time error
+    (:func:`_dispatched_error`) matches it exactly, that's the same blocker
+    recurring unchanged — not a fresh conflict — so it now consumes the cap
+    too. Callers that don't pass *current_error* keep the pre-#2475 behaviour
+    (``done`` never blocks) since they have no error text to compare.
     """
     if merge_entry_id is None:
         return False
@@ -393,9 +430,16 @@ def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
         # Genuine failure — retry cap consumed, surface to human.
         if a.status in ("failed", "advisory"):
             return True
-        # "done" = successful rebase → cap not consumed; a re-conflict is new.
-        # "cancelled" falls through here too — a cancelled attempt did no work,
-        # so it is treated the same as "done": re-dispatch is allowed.
+        if a.status == "done":
+            if current_error is not None and _dispatched_error(a) == current_error:
+                # Same failure text recurring after a "successful" fix means
+                # nothing was actually fixed — treat like a genuine failure.
+                return True
+            # Otherwise: successful rebase, different (or unknown) situation
+            # now → cap not consumed; a re-conflict is new.
+        # "cancelled" falls through here too — a cancelled attempt did no
+        # work, so it is treated the same as an unrelated "done": re-dispatch
+        # is allowed.
     return False
 
 
@@ -463,7 +507,10 @@ def dispatch_conflict_fix(
     the caller marks the entry ``HUMAN_REQUIRED``.  A ``done`` (successful)
     conflict-fix does *not* block a new dispatch — a successful rebase can be
     followed by a fresh conflict if other PRs merged in the meantime, and that
-    warrants a new attempt rather than an immediate human escalation (#784).
+    warrants a new attempt rather than an immediate human escalation (#784) —
+    UNLESS (#2475) *entry.error* is identical to the error the prior ``done``
+    attempt was dispatched for, which means the merge failed the same way
+    again with nothing actually fixed; see :func:`has_prior_conflict_fix`.
 
     ``semantic=True`` (#1291) dispatches the escalated second attempt: a
     different, less prescriptive briefing (see
@@ -481,7 +528,9 @@ def dispatch_conflict_fix(
             return None
         if _has_active_conflict_fix(board, entry.assignment_id):
             return None
-    elif has_prior_conflict_fix(board, entry.assignment_id):
+    elif has_prior_conflict_fix(
+        board, entry.assignment_id, current_error=entry.error,
+    ):
         return None
 
     repo = config.repo(entry.repo_name)

{code_coordinator-0.5.186 → code_coordinator-0.5.188}/coord/merge_queue.py

@@ -93,6 +93,18 @@ _HUMAN_SIGNALS = (
     "permission",
     "protected branch",
     "branch protection",
+    # #2475: GitHub's wording when a required status check can never report
+    # — e.g. its source CI job was deleted from the workflow while the
+    # check was still required in branch protection. This is a *permanent*
+    # block; no rebase or content change fixes it. The full message is
+    # something like "Pull request X is not mergeable: the base branch
+    # policy prohibits the merge.", which also contains "not mergeable" —
+    # a _REBASEABLE_SIGNALS entry — so without this specific phrase here,
+    # classify_conflict fell through past _HUMAN_SIGNALS (no match) to
+    # _REBASEABLE_SIGNALS's generic "not mergeable" match and misclassified
+    # the failure as "rebaseable", dispatching a conflict-fix worker that
+    # could never succeed (#2009's 38-turn thrash).
+    "policy prohibits the merge",
 )
 
 

{code_coordinator-0.5.186 → code_coordinator-0.5.188}/coord/notify.py

@@ -884,7 +884,11 @@ def detect_stalled_pipeline(
             elif (
                 matching_entry.state == CONFLICT
                 and classify_conflict(matching_entry.error) == "rebaseable"
-                and not has_prior_conflict_fix(board, matching_entry.assignment_id)
+                and not has_prior_conflict_fix(
+                    board,
+                    matching_entry.assignment_id,
+                    current_error=matching_entry.error,
+                )
             ):
                 # #1478: a rebaseable CONFLICT with no active/failed
                 # conflict-fix attempt — the #1474 classify-and-dispatch step
@@ -1412,7 +1416,9 @@ def dispatch_stalled_pipeline_action(
             return StalledDispatchAction(
                 kind="no_action", detail="merge queue entry no longer found",
             )
-        if has_prior_conflict_fix(board, entry.assignment_id):
+        if has_prior_conflict_fix(
+            board, entry.assignment_id, current_error=entry.error,
+        ):
             return StalledDispatchAction(
                 kind="skipped_human_required",
                 detail="conflict-fix already active or its retry cap was already hit",
@@ -2127,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()
@@ -2158,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:
@@ -2832,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.186 → code_coordinator-0.5.188}/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: