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

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

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

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

{code_coordinator-0.5.187 → 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.187 → code_coordinator-0.5.188}/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.188}/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.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:

{code_coordinator-0.5.187 → code_coordinator-0.5.188}/tests/test_cli_merge.py

@@ -3466,3 +3466,119 @@ class TestMergeSweepsSiblingsEndToEnd:
             f"expected HUMAN_REQUIRED, got {rows['a-309'].state!r} — the "
             "retry-cap escalation was dropped on the floor"
         )
+
+
+class TestBackfillReviewCost:
+    """#2476: `coord backfill-review-cost` — one-shot repair for review rows
+    the completion-capture gap left at cost_usd IS NULL/0."""
+
+    def _record_review(self, assignment_id: str, *, status: str = "done") -> None:
+        from coord.models import Assignment
+        from coord.state import get_connection, record_dispatched_assignment
+
+        assignment = Assignment(
+            assignment_id=assignment_id,
+            machine_name="laptop",
+            repo_name="api",
+            issue_number=42,
+            issue_title="[review] Fix the thing",
+            briefing="review briefing",
+            type="review",
+            review_target="99",
+            dispatched_at=1000.0,
+        )
+        record_dispatched_assignment(assignment=assignment, repo_github="acme/api")
+        conn = get_connection()
+        conn.execute(
+            "UPDATE assignments SET status=?, finished_at=1234.0 "
+            "WHERE assignment_id=?",
+            (status, assignment_id),
+        )
+        conn.commit()
+
+    def test_recovers_cost_from_local_log(
+        self, config_file: Path, coord_dir: Path, tmp_path: Path, monkeypatch,
+    ) -> None:
+        """A review row with cost_usd NULL and a local log carrying
+        total_cost_usd is recovered — same writers the live path uses."""
+        import json
+
+        self._record_review("bf1")
+        logs_dir = tmp_path / "logs"
+        logs_dir.mkdir()
+        monkeypatch.setattr("coord.usage.LOGS_DIR", logs_dir)
+        (logs_dir / "bf1.log").write_text(
+            json.dumps({
+                "type": "result", "subtype": "success", "result": "done",
+                "total_cost_usd": 2.5, "num_turns": 4, "duration_ms": 9999,
+                "session_id": "s", "input_tokens": 10, "output_tokens": 20,
+            }) + "\n",
+            encoding="utf-8",
+        )
+
+        result = CliRunner().invoke(
+            main, ["backfill-review-cost", "--config", str(config_file)]
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Recovered cost/tokens for 1 assignment(s)" in result.output
+
+        from coord.state import get_connection
+        row = get_connection().execute(
+            "SELECT cost_usd, input_tokens, output_tokens "
+            "FROM assignments WHERE assignment_id='bf1'"
+        ).fetchone()
+        assert row["cost_usd"] == 2.5
+        assert row["input_tokens"] == 10
+        assert row["output_tokens"] == 20
+
+    def test_reports_still_missing_when_log_unavailable(
+        self, config_file: Path, coord_dir: Path, tmp_path: Path, monkeypatch,
+    ) -> None:
+        """A row whose log is gone (no local file, agent unreachable) is
+        reported as still-missing rather than silently dropped — the
+        residual gap must stay visible."""
+        self._record_review("bf2")
+        monkeypatch.setattr("coord.usage.LOGS_DIR", tmp_path / "no-such-logs-dir")
+
+        result = CliRunner().invoke(
+            main, ["backfill-review-cost", "--config", str(config_file)]
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Recovered cost/tokens for 0 assignment(s)" in result.output
+        assert "1 assignment(s) still missing" in result.output
+        assert "bf2" in result.output
+
+        from coord.state import get_connection
+        row = get_connection().execute(
+            "SELECT cost_usd FROM assignments WHERE assignment_id='bf2'"
+        ).fetchone()
+        assert row["cost_usd"] is None
+
+    def test_no_candidates_message(
+        self, config_file: Path, coord_dir: Path,
+    ) -> None:
+        """An empty backlog prints a clear message instead of an empty report."""
+        result = CliRunner().invoke(
+            main, ["backfill-review-cost", "--config", str(config_file)]
+        )
+        assert result.exit_code == 0, result.output
+        assert "No review assignments with missing cost/tokens found." in result.output
+
+    def test_already_costed_row_is_not_a_candidate(
+        self, config_file: Path, coord_dir: Path,
+    ) -> None:
+        """A review row that already has cost_usd set is never re-touched —
+        safe to re-run against a repo that's already been backfilled."""
+        self._record_review("bf3")
+        from coord.state import get_connection
+        conn = get_connection()
+        conn.execute("UPDATE assignments SET cost_usd=1.0 WHERE assignment_id='bf3'")
+        conn.commit()
+
+        result = CliRunner().invoke(
+            main, ["backfill-review-cost", "--config", str(config_file)]
+        )
+        assert result.exit_code == 0, result.output
+        assert "No review assignments with missing cost/tokens found." in result.output