code-coordinator 0.5.184__tar.gz → 0.5.185__tar.gz

{code_coordinator-0.5.184 → code_coordinator-0.5.185}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.184",
+  "tag": "0.5.185",
   "distance": 0,
-  "node": "gea4dcf394483b237b6756e217d1187c0b24b598c",
+  "node": "g2d150e839b7920ff70d6be0f4983503f6a092831",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.184 → code_coordinator-0.5.185}/coord/reports.py

@@ -2623,6 +2623,13 @@ COMPLETED_COLUMNS = [
     "title",
     "started_at",
     "ended_at",
+    # #2472's four. Appended, never interleaved: the client addresses columns
+    # by INDEX for sorting (`reports_sort_by_column`), so inserting one in the
+    # middle would silently re-point a saved sort at a different column.
+    "legs",
+    "tokens_in",
+    "tokens_out",
+    "cost_total",
 ]
 
 # One entry per COMPLETED_COLUMNS entry, same order (#1760).
@@ -2633,14 +2640,109 @@ COMPLETED_COLUMNS = [
 # server-side report has no such screen context, and its `repo` param
 # defaults to *all repos*, so the pair has to be two real columns — which is
 # also what `issue-activity` already does, and what `RowIdentity` reads.
+#
+# #2472's spend columns reuse `_USAGE_COLUMN_META`'s labels/kinds verbatim
+# (`Legs`, `Tok In`, `Tok Out`, `Total $`) rather than inventing near-synonyms:
+# an operator reading `completed` and `usage` side by side is looking at the
+# same numbers out of the same rollup, and two spellings of "Tok In" would
+# imply otherwise.
+#
+# ONE cost column, not `usage`'s `cost_captured`/`cost_est` split. `usage`
+# splits because it is the dedicated cost report, where "some legs have no
+# captured cost, don't silently price at $0" (#1763) is the headline; here the
+# headline is still the time-range list, and a 5-column table growing to 11
+# would push `title` off a narrow pane. Both halves still ship as extra ROW
+# keys (see `_completed_spend`) — the wire contract allows row keys beyond
+# `columns`, so a client that wants the split has it without another column,
+# and `usage` remains the report to visit for it on screen.
 COMPLETED_COLUMN_META = [
     ColumnMeta(id="repo", label="Repo", kind="text"),
     ColumnMeta(id="issue", label="Issue", kind="int", align="right"),
     ColumnMeta(id="title", label="Title", kind="text", weight=3.0),
     ColumnMeta(id="started_at", label="Started", kind="timestamp"),
     ColumnMeta(id="ended_at", label="Ended", kind="timestamp"),
+    ColumnMeta(id="legs", label="Legs", kind="int", align="right", weight=0.6),
+    ColumnMeta(id="tokens_in", label="Tok In", kind="int", align="right"),
+    ColumnMeta(id="tokens_out", label="Tok Out", kind="int", align="right"),
+    ColumnMeta(id="cost_total", label="Total $", kind="money", align="right"),
 ]
 
+def _completed_spend(
+    assignment_rows: Sequence[Mapping[str, Any]], pricing: Any
+) -> dict[tuple[str, int], dict[str, Any]]:
+    """Per-issue ``legs``/tokens/cost, keyed ``(repo_name, issue_number)``.
+
+    A thin adapter over :func:`coord.usage_rollup.rollup`, **not** a second
+    cost calculator: the pricing rules, the captured-vs-estimated split and
+    the "never silently priced at $0" unknown-model rule all stay in
+    ``usage_rollup``, exactly as #1763 requires, and the numbers are shaped by
+    the same :func:`_usage_metrics` that builds a ``usage`` row.  ``legs``
+    therefore counts agent SESSIONS (every dispatch attempt and retry), which
+    is what ``GroupRollup.legs`` already means — no new arithmetic here.
+
+    One keying detail worth being explicit about: ``rollup``'s ``IssueKey``
+    books a leg to :func:`~coord.usage_rollup.row_issue_number`, i.e.
+    ``for_issue_number`` when the leg carries one (#1553's oracle-loop
+    attribution), while this fold's own ``first_dispatch``/``last_finish`` key
+    on the raw ``issue_number``.  That divergence is DELIBERATE: the whole
+    point of #2472 is that ``completed``'s cost for an issue equals what
+    ``usage`` reports for the same issue, so the cost columns must use
+    ``usage``'s attribution rule.  The timestamps keep #2454's, which is a
+    port of ``completed_rows``.
+    """
+    from coord.usage_rollup import IssueKey, TimeWindow, rollup  # noqa: PLC0415
+
+    # THE WINDOW IS UNBOUNDED — the spend figures are the issue's *lifetime*
+    # spend, not spend inside the report's own window.
+    #
+    # `completed`'s `since`/`until` filters on ENDED — "what finished in this
+    # range". An issue's legs routinely ran before that window opened (a 24h
+    # window over an issue dispatched a week ago is the normal case, not the
+    # edge case), so windowing the cost the same way would answer "what did
+    # this issue cost me *today*" under a column an operator reads as "what did
+    # finishing this issue cost me" — and would report a smaller number every
+    # time the window narrowed, for an issue whose true cost never changed.
+    # `usage` is where a windowed spend question belongs; it has a `window`
+    # param and this report does not.
+    #
+    # Consequence worth stating: an unbounded `TimeWindow` still drops a leg
+    # with NEITHER `dispatched_at` NOR `finished_at` (`leg_in_window` needs one
+    # of the two to be in range, and `contains(None)` is False). Such a row is
+    # not a session that ran — it is a row with no evidence it ever started —
+    # and `usage` excludes it on the same rule.
+    result = rollup(
+        [dict(a) for a in assignment_rows],
+        group_by="issue",
+        window=TimeWindow(),
+        pricing=pricing,
+    )
+    spend: dict[tuple[str, int], dict[str, Any]] = {}
+    for key, group in result.groups.items():
+        if not isinstance(key, IssueKey) or not key.repo_name:
+            continue
+        spend[(str(key.repo_name), int(key.issue_number))] = _usage_metrics(group)
+    return spend
+
+
+#: What a row gets when the rollup saw no legs at all for its issue — a real
+#: zero, not a missing key. An issue can be closed with no assignment ever
+#: dispatched against it (closed by hand, or fixed as a drive-by in someone
+#: else's PR), and that row's honest answer is "0 legs, $0", not a blank cell
+#: a client would have to guess the meaning of.
+_COMPLETED_NO_LEGS: dict[str, Any] = {
+    "legs": 0,
+    "tokens_in": 0,
+    "tokens_out": 0,
+    "cost_captured": 0.0,
+    "cost_est": 0.0,
+    "cost_total": 0.0,
+    "tokens_cache_read": 0,
+    "tokens_cache_creation": 0,
+    "duration_secs": 0.0,
+    "open_legs": 0,
+    "unknown_model_legs": 0,
+}
+
 
 def fold_completed(
     issues: Iterable[Mapping[str, Any]],
@@ -2650,6 +2752,8 @@ def fold_completed(
     *,
     repo: str = "",
     generated_at: float | None = None,
+    pricing: Any = None,
+    extra_notes: Sequence[str] = (),
 ) -> ReportResult:
     """Fold the board's own tables into one row per issue that *finished*
     inside ``window``.
@@ -2658,6 +2762,12 @@ def fold_completed(
     above is testable without a database (same posture as
     :func:`fold_issue_activity`).  Rows come back newest-ENDED first, which
     is #2405's default order; the client re-sorts by column head-click.
+
+    *pricing* left at ``None`` falls through to ``usage_rollup``'s built-in
+    default rates, which is correct for a unit test and **not** what the
+    runner does — :func:`run_completed` loads ``coordinator.yml`` and passes
+    the real ``pricing:`` block, the same seam :func:`fold_usage` uses and for
+    the same #1763 reason.
     """
     start, end = window
     generated_at = time.time() if generated_at is None else float(generated_at)
@@ -2719,6 +2829,8 @@ def fold_completed(
             if value is not None and value > last_finish.get(key, float("-inf")):
                 last_finish[key] = value
 
+    spend = _completed_spend(assignment_rows, pricing)
+
     rows: list[dict] = []
     no_end_time = 0
     for issue in issue_rows:
@@ -2752,6 +2864,10 @@ def fold_completed(
                 "title": str(issue.get("title") or "") or None,
                 "started_at": first_dispatch.get(key),
                 "ended_at": ended,
+                # #2472. `**` copies the pairs into this row's own dict, so
+                # the shared `_COMPLETED_NO_LEGS` constant can never end up
+                # aliased by two zero-leg rows.
+                **spend.get(key, _COMPLETED_NO_LEGS),
             }
         )
 
@@ -2760,7 +2876,7 @@ def fold_completed(
     # `sort_completed_rows` takes the same precaution for the same reason).
     rows.sort(key=lambda r: (-float(r["ended_at"]), r["repo"], r["issue"]))
 
-    notes: list[str] = []
+    notes: list[str] = list(extra_notes)
     if no_end_time:
         notes.append(
             f"{no_end_time} completed issue(s) have no end timestamp (no merged "
@@ -2774,6 +2890,27 @@ def fold_completed(
             f"No issue in this board belongs to repo {repo_filter!r} — check the "
             "coord-local repo name (the one in coordinator.yml), not the GitHub slug."
         )
+    # #1763's rule is "never silently priced at $0", and `cost_total` here is
+    # exactly the number that would go silently short. So it IS noted — but as
+    # ONE aggregate line rather than `fold_usage`'s line-per-issue: this report
+    # is a time-range list that can easily carry a hundred rows, and a hundred
+    # near-identical notes would bury the two above that are about the list
+    # itself. The per-issue breakdown is a question for `usage`, which the note
+    # names.
+    unpriced = sorted(
+        f"{r['repo']}#{r['issue']}" for r in rows if r.get("unknown_model_legs")
+    )
+    if unpriced:
+        shown = ", ".join(unpriced[:5])
+        more = f" (and {len(unpriced) - 5} more)" if len(unpriced) > 5 else ""
+        notes.append(
+            f"{len(unpriced)} issue(s) ran leg(s) on a model with no entry in "
+            f"the loaded `pricing:` config — {shown}{more}. Their tokens are "
+            "counted but that spend is NOT in `Total $` (never silently priced "
+            "at $0), so those rows read LOW. Add a rate for the model to "
+            "coordinator.yml, or run the `usage` report for the per-issue "
+            "breakdown."
+        )
 
     return ReportResult(
         report_id="completed",
@@ -2805,10 +2942,21 @@ def _default_completed_source() -> tuple[list[dict], list[dict], list[dict]]:
                 "SELECT repo_name, number, title, state FROM issues"
             ).fetchall()
         ]
+        # #2472 widens this one SELECT rather than adding a second source
+        # function: the spend columns fold out of the SAME assignment rows the
+        # timestamps do, so a second round trip would re-read the same table to
+        # get columns this one could have carried. Everything past
+        # `finished_at` is what `usage_rollup.rollup`/`leg_cost` read — token
+        # counts, the captured `cost_usd`, the `model` its estimate is keyed
+        # by, and `for_issue_number` for #1553's attribution. `type` is NOT
+        # selected: it only feeds `usage`'s per-stage drill-down, which this
+        # report does not emit.
         assignments = [
             dict(r)
             for r in conn.execute(
-                "SELECT repo_name, issue_number, dispatched_at, finished_at "
+                "SELECT repo_name, issue_number, for_issue_number, "
+                "dispatched_at, finished_at, input_tokens, output_tokens, "
+                "cache_read_tokens, cache_creation_tokens, cost_usd, model "
                 "FROM assignments"
             ).fetchall()
         ]
@@ -2834,9 +2982,10 @@ def run_completed(
         Sequence[Mapping[str, Any]],
         Sequence[Mapping[str, Any]],
     ]] | None = None,
+    pricing: Any = None,
 ) -> ReportResult:
-    """Read the board and fold it.  ``now``/``source`` are test seams
-    (mirrors :func:`run_issue_activity`); the report's own parameters are
+    """Read the board and fold it.  ``now``/``source``/``pricing`` are test
+    seams (mirrors :func:`run_issue_activity`); the report's own parameters are
     ``since``/``until``/``repo`` — the same three, with the same vocabulary
     and the same validators, that ``issue-activity`` uses."""
     generated_at = time.time() if now is None else float(now)
@@ -2844,6 +2993,15 @@ def run_completed(
     start = end - parse_duration(since)
     source_fn = _default_completed_source if source is None else source
     issues, assignments, merge_queue = source_fn()
+
+    # Same seam, same reason as `run_usage`: the estimated half of `cost_total`
+    # has to be priced off the fleet's OWN `pricing:` block, and a config that
+    # could not be loaded says so in a note instead of silently falling back
+    # (#1763).
+    extra_notes: list[str] = []
+    if pricing is None:
+        pricing, extra_notes = _load_pricing()
+
     return fold_completed(
         issues,
         assignments,
@@ -2851,6 +3009,8 @@ def run_completed(
         (start, end),
         repo=repo,
         generated_at=generated_at,
+        pricing=pricing,
+        extra_notes=extra_notes,
     )
 
 
@@ -2938,7 +3098,12 @@ COMPLETED = ReportDef(
         "merged (the PR closed it before the brain synced the close). ENDED is "
         "the merge timestamp, falling back to the last assignment to finish; "
         "STARTED is the first dispatch. Issues with no end timestamp at all "
-        "cannot be placed in a time range and are counted in a note instead."
+        "cannot be placed in a time range and are counted in a note instead. "
+        "Each row also carries what it cost: LEGS is how many agent sessions "
+        "(dispatches and retries) ran against the issue, and the token and "
+        "dollar figures are the issue's WHOLE-LIFE spend — not just the part "
+        "inside this window — so narrowing the range never shrinks them. Use "
+        "the `usage` report for windowed spend or the captured/estimated split."
     ),
     params=(
         # The same three params, the same vocabulary and the same validators

{code_coordinator-0.5.184 → code_coordinator-0.5.185}/tests/test_reports.py

@@ -36,6 +36,7 @@ from coord.drive_queue import QUEUE_ALERT_ISSUE, QUEUE_ALERT_REPO
 from coord.gate_a import park_marker
 from coord.models import POLICY_REFUSAL_MARKER
 from coord.reports import (
+    COMPLETED_COLUMNS,
     REPORTS,
     ColumnMeta,
     ReportError,
@@ -4027,15 +4028,34 @@ def _completed_issues() -> list[dict]:
 
 
 def _completed_assignments() -> list[dict]:
+    """#2454's timestamps plus #2472's spend, on the same rows.
+
+    The spend numbers are chosen to be exact under the DEFAULT
+    :class:`~coord.config.PricingConfig` (sonnet input is $3.00/Mtok — see
+    `TestUsagePricingFollowsConfig`), so the assertions can name a dollar
+    figure instead of an approximation of one:
+
+      * myrepo#7's first leg estimates to exactly $3.00 and its RETRY carries a
+        captured $2.00, so the issue is 2 legs / $5.00 — and the two halves
+        exercise both branches of `leg_cost` in one row.
+      * myrepo#9 is merged with NO assignment at all: 0 legs, $0.
+      * other#7 is a fat leg that must not leak into myrepo#7's spend any more
+        than it leaks into its timestamps.
+    """
     return [
         # Two legs on #7 — STARTED is the FIRST dispatch, ENDED the LAST finish.
-        {"repo_name": "myrepo", "issue_number": 7, "dispatched_at": 100.0, "finished_at": 200.0},
-        {"repo_name": "myrepo", "issue_number": 7, "dispatched_at": 150.0, "finished_at": 250.0},
-        {"repo_name": "myrepo", "issue_number": 11, "dispatched_at": 900.0, "finished_at": None},
-        {"repo_name": "other", "issue_number": 13, "dispatched_at": 50.0, "finished_at": 300.0},
+        {"repo_name": "myrepo", "issue_number": 7, "dispatched_at": 100.0, "finished_at": 200.0,
+         "model": "sonnet", "input_tokens": 1_000_000, "output_tokens": 0},
+        {"repo_name": "myrepo", "issue_number": 7, "dispatched_at": 150.0, "finished_at": 250.0,
+         "model": "sonnet", "cost_usd": 2.0, "input_tokens": 10, "output_tokens": 4},
+        {"repo_name": "myrepo", "issue_number": 11, "dispatched_at": 900.0, "finished_at": None,
+         "model": "sonnet", "input_tokens": 500, "output_tokens": 500},
+        {"repo_name": "other", "issue_number": 13, "dispatched_at": 50.0, "finished_at": 300.0,
+         "model": "sonnet", "cost_usd": 0.5, "input_tokens": 7, "output_tokens": 3},
         # Same issue NUMBER in a different repo — must not contribute to
-        # myrepo#7's timestamps.
-        {"repo_name": "other", "issue_number": 7, "dispatched_at": 1.0, "finished_at": 9999.0},
+        # myrepo#7's timestamps, nor to its tokens or cost.
+        {"repo_name": "other", "issue_number": 7, "dispatched_at": 1.0, "finished_at": 9999.0,
+         "model": "sonnet", "cost_usd": 999.0, "input_tokens": 9_000_000, "output_tokens": 9_000},
     ]
 
 
@@ -4063,7 +4083,12 @@ class TestCompletedFold:
     def test_columns_are_the_wire_contract(self) -> None:
         result = _fold_completed()
         assert result.report_id == "completed"
-        assert result.columns == ["repo", "issue", "title", "started_at", "ended_at"]
+        assert result.columns == [
+            "repo", "issue", "title", "started_at", "ended_at",
+            # #2472's four, APPENDED — the client sorts by column index, so
+            # #2454's five must keep the indices they had.
+            "legs", "tokens_in", "tokens_out", "cost_total",
+        ]
         assert [m.id for m in result.column_meta] == result.columns
 
     def test_only_closed_or_merged_issues_appear(self) -> None:
@@ -4145,6 +4170,243 @@ class TestCompletedFold:
         json.dumps(_fold_completed().to_dict())
 
 
+class TestCompletedSpend:
+    """#2472: the spend half of a row — `legs`, tokens and `cost_total`.
+
+    Every number here comes out of `coord.usage_rollup.rollup`; these tests
+    pin the *joining* (right issue, right repo, right window) and the fact
+    that `completed` and `usage` cannot disagree, which is the whole point of
+    reusing the rollup instead of writing a second cost calculator.
+    """
+
+    def _row(self, issue: int = 7, repo: str = "myrepo", **kw) -> dict:
+        return next(
+            r for r in _fold_completed(**kw).rows
+            if r["repo"] == repo and r["issue"] == issue
+        )
+
+    def test_legs_counts_agent_sessions_not_issues(self) -> None:
+        """myrepo#7 was dispatched twice — a retry. `legs` is 2, not 1."""
+        assert self._row(7)["legs"] == 2
+        # …and an issue with a single leg reads 1, so `legs` is not just
+        # "number of rows folded".
+        assert self._row(13, repo="other")["legs"] == 1
+
+    def test_tokens_are_summed_across_every_leg(self) -> None:
+        row = self._row(7)
+        assert row["tokens_in"] == 1_000_010  # 1_000_000 + 10
+        assert row["tokens_out"] == 4         # 0 + 4
+
+    def test_cost_total_is_captured_plus_estimated(self) -> None:
+        row = self._row(7)
+        # The retry's captured $2.00 is kept verbatim; the first leg has no
+        # captured cost so its 1M sonnet input tokens estimate to $3.00.
+        assert row["cost_total"] == pytest.approx(5.0)
+
+    def test_the_captured_estimated_split_ships_as_extra_row_keys(self) -> None:
+        """One `Total $` COLUMN, but no information thrown away — a client
+        that wants `usage`'s split can read it off the row."""
+        row = self._row(7)
+        assert row["cost_captured"] == pytest.approx(2.0)
+        assert row["cost_est"] == pytest.approx(3.0)
+        assert "cost_captured" not in COMPLETED_COLUMNS
+        assert "cost_est" not in COMPLETED_COLUMNS
+
+    def test_spend_is_scoped_by_coord_local_repo(self) -> None:
+        """other#7's fat leg ($999, 9M tokens) must not reach myrepo#7 — the
+        same scoping the timestamps get, applied to the money."""
+        row = self._row(7)
+        assert row["cost_total"] == pytest.approx(5.0)
+        assert row["tokens_in"] == 1_000_010
+
+    def test_spend_is_lifetime_not_windowed(self) -> None:
+        """The documented call: the window filters ENDED, never the legs.
+
+        myrepo#7's legs were dispatched at 100/150 and the window opens at
+        240 — a windowed figure would report $2.00 (or $0) here. It reports
+        the issue's whole-life $5.00, because "what did finishing this issue
+        cost me" must not shrink when the operator narrows the range.
+        """
+        wide = self._row(7)
+        narrow = self._row(7, window=(240.0, C_END))
+        assert narrow["ended_at"] == 250.0, "still in the window"
+        assert narrow["legs"] == wide["legs"] == 2
+        assert narrow["cost_total"] == wide["cost_total"] == pytest.approx(5.0)
+        assert narrow["tokens_in"] == wide["tokens_in"]
+
+    def test_an_issue_with_no_legs_reads_zero_not_blank(self) -> None:
+        """myrepo#9 is merged with no assignment against it at all."""
+        row = self._row(9)
+        assert row["legs"] == 0
+        assert row["tokens_in"] == 0
+        assert row["tokens_out"] == 0
+        assert row["cost_total"] == 0.0
+        # A real 0, not a hole a client would have to render as "?".
+        for column in COMPLETED_COLUMNS:
+            assert column in row
+
+    def test_the_no_legs_default_is_not_shared_between_rows(self) -> None:
+        """`_COMPLETED_NO_LEGS` is a module constant; two zero-leg rows must
+        not end up aliasing one mapping."""
+        result = fold_completed(
+            [
+                {"repo_name": "r", "number": 1, "title": "a", "state": "closed"},
+                {"repo_name": "r", "number": 2, "title": "b", "state": "closed"},
+            ],
+            [],
+            [
+                {"repo_name": "r", "issue_number": 1, "state": "merged", "last_attempt": 10.0},
+                {"repo_name": "r", "issue_number": 2, "state": "merged", "last_attempt": 20.0},
+            ],
+            (C_START, C_END),
+            generated_at=C_END,
+        )
+        first, second = result.rows
+        first["legs"] = 99
+        assert second["legs"] == 0
+
+    def test_every_completed_row_agrees_with_the_usage_report(self) -> None:
+        """The load-bearing guard, and the reason #2472 exists: an operator
+        must never have to open `usage` and cross-reference by issue number to
+        find a different number for the same issue."""
+        from coord.config import PricingConfig
+        from coord.reports import fold_usage
+        from coord.usage_rollup import TimeWindow
+
+        pricing = PricingConfig()
+        completed = _fold_completed(pricing=pricing)
+        usage = fold_usage(
+            _completed_assignments(),
+            TimeWindow(start=None, end=None, label="all"),
+            group_by="issue",
+            pricing=pricing,
+        )
+        by_issue = {(r["repo"], r["issue"]): r for r in usage.rows}
+
+        checked = 0
+        for row in completed.rows:
+            peer = by_issue.get((row["repo"], row["issue"]))
+            if peer is None:
+                assert row["legs"] == 0, "only a no-leg issue may be absent from usage"
+                continue
+            for key in ("legs", "tokens_in", "tokens_out"):
+                assert row[key] == peer[key], f"{row['repo']}#{row['issue']} {key}"
+            assert row["cost_total"] == pytest.approx(peer["cost_total"])
+            checked += 1
+        assert checked >= 2, "the comparison must actually have compared something"
+
+    def test_a_leg_booked_to_another_issue_follows_usages_attribution(self) -> None:
+        """#1553: a leg carrying `for_issue_number` is spend on THAT issue.
+
+        `completed`'s timestamps key on the raw `issue_number` (#2454's rule,
+        a port of `completed_rows`), but the cost columns must key the way
+        `usage` does or the two reports would disagree — which is exactly what
+        the previous test forbids.
+        """
+        result = fold_completed(
+            [{"repo_name": "myrepo", "number": 7, "title": "t", "state": "closed"}],
+            [
+                {"repo_name": "myrepo", "issue_number": 7,
+                 "dispatched_at": 100.0, "finished_at": 200.0,
+                 "model": "sonnet", "cost_usd": 1.0},
+                # An oracle-loop acceptance slice: filed under the milestone's
+                # tracking issue 999, but its spend belongs to #7.
+                {"repo_name": "myrepo", "issue_number": 999, "for_issue_number": 7,
+                 "dispatched_at": 300.0, "finished_at": 400.0,
+                 "model": "sonnet", "cost_usd": 4.0},
+            ],
+            [],
+            (C_START, C_END),
+            generated_at=C_END,
+        )
+        row = result.rows[0]
+        assert row["legs"] == 2
+        assert row["cost_total"] == pytest.approx(5.0)
+        # …while ENDED stays #2454's: the last finish of an assignment whose
+        # own `issue_number` is 7.
+        assert row["ended_at"] == 200.0
+
+    def test_an_unpriced_model_is_noted_rather_than_shown_as_zero(self) -> None:
+        """#1763's rule, kept: a leg on a model with no `pricing:` entry is
+        never silently priced at $0."""
+        result = fold_completed(
+            [{"repo_name": "myrepo", "number": 7, "title": "t", "state": "closed"}],
+            [{"repo_name": "myrepo", "issue_number": 7,
+              "dispatched_at": 100.0, "finished_at": 200.0,
+              "model": "gpt-hypothetical", "input_tokens": 500, "output_tokens": 500}],
+            [],
+            (C_START, C_END),
+            generated_at=C_END,
+        )
+        row = result.rows[0]
+        # Tokens counted, spend NOT invented.
+        assert row["tokens_in"] == 500
+        assert row["cost_total"] == 0.0
+        note = next(n for n in result.notes if "pricing" in n)
+        assert "myrepo#7" in note
+        assert "read LOW" in note
+
+    def test_the_unpriced_note_is_one_line_not_one_per_issue(self) -> None:
+        """`usage` emits a note per issue; `completed` is a time-range list
+        that can carry a hundred rows, so it aggregates."""
+        issues = [
+            {"repo_name": "myrepo", "number": n, "title": "t", "state": "closed"}
+            for n in range(1, 9)
+        ]
+        assignments = [
+            {"repo_name": "myrepo", "issue_number": n,
+             "dispatched_at": 10.0 * n, "finished_at": 20.0 * n,
+             "model": "gpt-hypothetical", "input_tokens": 10, "output_tokens": 10}
+            for n in range(1, 9)
+        ]
+        result = fold_completed(
+            issues, assignments, [], (C_START, C_END), generated_at=C_END
+        )
+        pricing_notes = [n for n in result.notes if "pricing" in n]
+        assert len(pricing_notes) == 1, pricing_notes
+        assert "8 issue(s)" in pricing_notes[0]
+        assert "and 3 more" in pricing_notes[0], "the list is capped, and says so"
+
+    def test_a_priced_fixture_still_produces_no_notes(self) -> None:
+        """The spend columns must not make every clean report noisy."""
+        assert _fold_completed().notes == []
+
+    def test_pricing_overrides_move_the_estimate(self) -> None:
+        """Same #1116/#1763 seam `usage` has: the fleet's own `pricing:` block
+        is what the dollar column is computed from, not a snapshot."""
+        from coord.config import ModelRates, PricingConfig
+
+        override = PricingConfig(models={"sonnet": ModelRates(input=9.0, output=0.0)})
+        row = self._row(7, pricing=override)
+        # The captured $2.00 is untouched; the estimated leg's 1M input tokens
+        # now price at $9.00 instead of $3.00.
+        assert row["cost_captured"] == pytest.approx(2.0)
+        assert row["cost_est"] == pytest.approx(9.0)
+        assert row["cost_total"] == pytest.approx(11.0)
+
+    def test_a_leg_with_no_timestamps_at_all_is_not_counted(self) -> None:
+        """Documented consequence of the unbounded rollup window: a row with
+        neither `dispatched_at` nor `finished_at` is not evidence a session
+        ran, and `usage` excludes it on the same rule."""
+        result = fold_completed(
+            [{"repo_name": "myrepo", "number": 7, "title": "t", "state": "closed"}],
+            [
+                {"repo_name": "myrepo", "issue_number": 7,
+                 "dispatched_at": 100.0, "finished_at": 200.0, "cost_usd": 1.0},
+                {"repo_name": "myrepo", "issue_number": 7,
+                 "dispatched_at": None, "finished_at": None, "cost_usd": 50.0},
+            ],
+            [],
+            (C_START, C_END),
+            generated_at=C_END,
+        )
+        assert result.rows[0]["legs"] == 1
+        assert result.rows[0]["cost_total"] == pytest.approx(1.0)
+
+    def test_the_result_is_still_json_serialisable(self) -> None:
+        json.dumps(_fold_completed().to_dict())
+
+
 class TestCompletedRunner:
     def test_since_and_until_bound_the_window(self) -> None:
         seen: list[tuple] = []
@@ -4200,9 +4462,20 @@ class TestCompletedAgainstTheRealSchema:
             )
             coord_db.execute(
                 "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
-                "issue_number, issue_title, status, dispatched_at, finished_at) "
+                "issue_number, issue_title, status, dispatched_at, finished_at, "
+                "model, cost_usd, input_tokens, output_tokens) "
                 "VALUES ('a1', 'precision', 'api', 1629, 'Closed and done', 'done', "
-                "1000.0, 2000.0)"
+                "1000.0, 2000.0, 'sonnet', 1.25, 4000, 700)"
+            )
+            # #2472: a RETRY, so `legs` has something to count past 1 and the
+            # widened SELECT is proved to read every leg's tokens, not just
+            # the first row's.
+            coord_db.execute(
+                "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
+                "issue_number, issue_title, status, dispatched_at, finished_at, "
+                "model, cost_usd, input_tokens, output_tokens) "
+                "VALUES ('a2', 'precision', 'api', 1629, 'Closed and done', 'done', "
+                "2100.0, 2200.0, 'sonnet', 0.75, 1000, 300)"
             )
             coord_db.execute(
                 "INSERT INTO merge_queue (assignment_id, repo_name, repo_github, "
@@ -4222,6 +4495,18 @@ class TestCompletedAgainstTheRealSchema:
         # The merged merge_queue row wins over the assignment's finished_at.
         assert row["ended_at"] == 2500.0
 
+    def test_the_widened_select_reaches_the_spend_columns(self, coord_db) -> None:
+        """#2472 added `for_issue_number`/tokens/`cost_usd`/`model` to that
+        SELECT. They are all migration-added columns, and the source swallows
+        every exception into an empty report — so a typo would show up as a
+        silently blank report, never a traceback. Hence this."""
+        self._seed(coord_db)
+        row = run_completed(since="7d", until="3000", repo="api").rows[0]
+        assert row["legs"] == 2, "both the first attempt and the retry"
+        assert row["tokens_in"] == 5000   # 4000 + 1000
+        assert row["tokens_out"] == 1000  # 700 + 300
+        assert row["cost_total"] == pytest.approx(2.0)  # 1.25 + 0.75, both captured
+
     def test_it_runs_through_the_cli(self, coord_db) -> None:
         self._seed(coord_db)
         result = CliRunner().invoke(
@@ -4266,8 +4551,14 @@ class TestCompletedCatalogue:
         text = result_to_csv(_fold_completed())
         # The header row is the `column_meta` LABELS (the shared serializer's
         # rule), and the values stay raw epochs — not display strings.
-        assert "Repo,Issue,Title,Started,Ended" in text
-        assert 'myrepo,9,"Merged, still open",,400.0' in text
+        # #2472's four labels are `usage`'s verbatim, so a spreadsheet built
+        # off one export lines up with the other.
+        assert "Repo,Issue,Title,Started,Ended,Legs,Tok In,Tok Out,Total $" in text
+        # myrepo#9 merged with no assignment: a real 0/0/0/0.0, not four
+        # empty cells.
+        assert 'myrepo,9,"Merged, still open",,400.0,0,0,0,0.0' in text
+        # myrepo#7's retry: 2 legs, $2.00 captured + $3.00 estimated.
+        assert "myrepo,7,Closed one,100.0,250.0,2,1000010,4,5.0" in text
 
 
 class TestRowIdentity: