fix(code-reviews): fix billing query timeout preventing usage footer on v2 reviews (#979)

## Summary

Follow-up to [PR #978](#978). The
billing fallback query that fetches token/model data for v2 reviews was
timing out in production, so the usage footer ("Reviewed by model · X
tokens") was never shown.

**Root cause:** the query filters `microdollar_usage_metadata` by
`session_id`, but that column has no index. The table has ~469M rows, so
every query did a full table scan and timed out. The `catch` block
silently returned `null`, and the footer was skipped.

**Fix:**
- Add a `created_at >= reviewCreatedAt` lower bound to the billing
query. This lets Postgres use the existing `created_at` index (query
cost drops from full-scan to ~288). Billing rows can't exist before the
review was created, so the bound is exact.
- Skip the v1 poll loop for v2 reviews (saves ~1.4s of wasted retries).
- Remove the `session_id` index migration — with the time bound, it's
not needed.
- Clean up the admin dashboard: remove agent version filter and
performance chart that are no longer useful now that all reviews are v2.

## Verification

- [x] `pnpm typecheck` — no new errors (only pre-existing kiloclaw
errors)
- [x] `pnpm test usage-footer` — 10/10 pass
- [x] `pnpm test schema` — 15/15 pass (no unmigrated schema changes)
- [x] Checked `EXPLAIN` plan on prod DB — query uses
`idx_microdollar_usage_metadata_created_at` with cost ~288
- [x] Confirmed billing data exists for test session
`ses_3282e02f5ffe2vPRBSqdpc0e40` (PR #981 review) — 8 rows returned in
<1s with time-bounded query

## Visual Changes

N/A

## Reviewer Notes

- Every completed v2 review in prod has `model = NULL` — the billing
fallback has never worked. This fix unblocks all future v2 reviews.
- The back-fill write (fire-and-forget) still runs after fetching
billing data, so repeat reads skip the aggregation.

Author: alex-alecu

src/app/api/internal/code-review-status/[reviewId]/route.ts

@@ -116,26 +116,29 @@ function normalizePayload(raw: StatusUpdatePayload): {
 }
 
 /**
- * Read a review's usage data, polling with exponential backoff if not yet available.
+ * Read a review's usage data.
  *
- * For v1 (SSE) reviews the orchestrator reports usage before the completion
- * callback fires, so a short poll handles the race.  For v2 (cloud-agent-next)
- * reviews the orchestrator never reports usage — we fall back to aggregating
- * from the billing tables (microdollar_usage) keyed by cli_session_id.
+ * For v1 (SSE) reviews the orchestrator writes usage to the record just
+ * before the completion callback, so a short poll handles the race.
+ * For v2 (cloud-agent-next) the orchestrator never writes usage — we
+ * skip the poll and go straight to the billing tables.
  *
- * When the billing fallback is used we also back-fill the code_reviews record
- * so subsequent reads (e.g. the admin panel) don't need the aggregation again.
+ * When the billing fallback is used we also back-fill the code_reviews
+ * record so later reads (e.g. admin panel) don't repeat the aggregation.
  */
 async function getReviewUsageData(reviewId: string) {
-  const MAX_RETRIES = 3;
-  const BASE_DELAY_MS = 200;
-
   let review = await getCodeReviewById(reviewId);
 
-  // Short poll: usage may arrive from the orchestrator just before the callback
-  for (let attempt = 0; attempt < MAX_RETRIES && review && !review.model; attempt++) {
-    await new Promise(resolve => setTimeout(resolve, BASE_DELAY_MS * 2 ** attempt));
-    review = await getCodeReviewById(reviewId);
+  // v1 only: poll briefly — usage may arrive from the orchestrator
+  // right before the callback. v2 never writes usage to the record,
+  // so polling would just waste ~1.4s for nothing.
+  if (review && !review.model && review.agent_version !== 'v2') {
+    const MAX_RETRIES = 3;
+    const BASE_DELAY_MS = 200;
+    for (let attempt = 0; attempt < MAX_RETRIES && review && !review.model; attempt++) {
+      await new Promise(resolve => setTimeout(resolve, BASE_DELAY_MS * 2 ** attempt));
+      review = await getCodeReviewById(reviewId);
+    }
   }
 
   if (review?.model) {
@@ -147,8 +150,8 @@ async function getReviewUsageData(reviewId: string) {
   }
 
   // Fallback: aggregate from billing tables (covers v2 / cloud-agent-next reviews)
-  if (review?.cli_session_id) {
-    const billing = await getSessionUsageFromBilling(review.cli_session_id);
+  if (review?.cli_session_id && review.created_at) {
+    const billing = await getSessionUsageFromBilling(review.cli_session_id, review.created_at);
     if (billing) {
       // Back-fill the code_reviews record so we don't repeat this aggregation
       updateCodeReviewUsage(reviewId, {

src/lib/code-reviews/db/code-reviews.ts

@@ -11,7 +11,7 @@ import {
   microdollar_usage,
   microdollar_usage_metadata,
 } from '@kilocode/db/schema';
-import { eq, and, desc, count, ne, inArray, sql, sum } from 'drizzle-orm';
+import { eq, and, desc, count, ne, inArray, sql, sum, gte } from 'drizzle-orm';
 import { captureException } from '@sentry/nextjs';
 import type { CreateReviewParams, CodeReviewStatus, ListReviewsParams, Owner } from '../core';
 import type { CloudAgentCodeReview } from '@kilocode/db/schema';
@@ -502,18 +502,20 @@ export type SessionUsageSummary = {
  * system (processUsage → microdollar_usage) already records per-request
  * usage keyed by session_id, so we aggregate here.
  *
- * Uses two queries:
- * 1. Session-wide totals (tokens + cost across all models)
- * 2. The model with the most tokens (the primary review model name)
- *
- * This avoids undercounting when a session uses more than one model.
+ * The `reviewCreatedAt` lower bound lets Postgres use the existing
+ * `idx_microdollar_usage_metadata_created_at` index instead of seq-scanning
+ * the full table (~469 M rows). Billing rows cannot exist before the review.
  */
 export async function getSessionUsageFromBilling(
-  cliSessionId: string
+  cliSessionId: string,
+  reviewCreatedAt: string
 ): Promise<SessionUsageSummary | null> {
   try {
-    const sessionFilter = eq(microdollar_usage_metadata.session_id, cliSessionId);
     const joinCondition = eq(microdollar_usage.id, microdollar_usage_metadata.id);
+    const sessionFilter = and(
+      eq(microdollar_usage_metadata.session_id, cliSessionId),
+      gte(microdollar_usage_metadata.created_at, reviewCreatedAt)
+    );
 
     // 1. Session-wide totals (all models combined)
     const [totals] = await db