@zaip-ai/cli 1.0.8 → 1.3.0

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostMonitorPage.test.ts

@@ -12,63 +12,112 @@ import {
   withTokenBackedCompactDuration,
 } from "./CompactLifecycleCostTable.js";
 import { costPeriodDateRange, defaultCostPeriod, emptyCostFilters } from "./CostFilters.js";
-import {
-  costGroupPageLabel,
-  effectiveCostGroupQuery,
-  reconcileCostGroupTotalsWithCards,
-} from "./use-cost-group-page.js";
 import {
   COST_VIEW_ORDER,
   DEFAULT_COST_VIEW,
   findRunDetails,
   groupRows,
+  isCostViewExportEligible,
   isCurrentCostRunPageGeneration,
   isServerCostRunPagingEligible,
   matchesGlobalFilters,
   matchesPeriodEntity,
+  resolveCompactCostPageRange,
   resolveCostGroupPageRange,
   selectDimensionalCostRows,
   visibleExecutionRows,
 } from "./CostMonitorPage.js";
+import {
+  costGroupPageLabel,
+  effectiveCostGroupQuery,
+  reconcileCostGroupTotalsWithCards,
+} from "./use-cost-group-page.js";
 
 describe("cost monitor navigation", () => {
+  it("hides Excel export from the overview while retaining it on tabular views", () => {
+    expect(isCostViewExportEligible("overview")).toBe(false);
+    expect(isCostViewExportEligible("daily")).toBe(true);
+    expect(isCostViewExportEligible("agentCalls")).toBe(true);
+  });
+
   it("keeps the embedded default group pager on the all-time snapshot without explicit filters", () => {
     const monthRange = costPeriodDateRange(defaultCostPeriod, new Date("2026-08-17T12:00:00.000Z"));
-    expect(resolveCostGroupPageRange({
-      embedded: true,
-      globalDateRange: undefined,
-      hasLocalCostFilters: false,
-      period: defaultCostPeriod,
-      runPageRange: monthRange,
-    })).toBeUndefined();
-    expect(resolveCostGroupPageRange({
-      embedded: true,
-      globalDateRange: undefined,
-      hasLocalCostFilters: false,
-      period: "30",
-      runPageRange: monthRange,
-    })).toEqual(monthRange);
-    expect(resolveCostGroupPageRange({
-      embedded: true,
-      globalDateRange: { start: "2026-07-14", end: "2026-08-17" },
-      hasLocalCostFilters: false,
-      period: defaultCostPeriod,
-      runPageRange: { from: "2026-07-14", to: "2026-08-17" },
-    })).toEqual({ from: "2026-07-14", to: "2026-08-17" });
-    expect(resolveCostGroupPageRange({
-      embedded: true,
-      globalDateRange: undefined,
-      hasLocalCostFilters: true,
-      period: defaultCostPeriod,
-      runPageRange: monthRange,
-    })).toEqual(monthRange);
+    expect(
+      resolveCostGroupPageRange({
+        embedded: true,
+        globalDateRange: undefined,
+        hasLocalCostFilters: false,
+        period: defaultCostPeriod,
+        runPageRange: monthRange,
+      }),
+    ).toBeUndefined();
+    expect(
+      resolveCostGroupPageRange({
+        embedded: true,
+        globalDateRange: undefined,
+        hasLocalCostFilters: false,
+        period: "30",
+        runPageRange: monthRange,
+      }),
+    ).toEqual(monthRange);
+    expect(
+      resolveCostGroupPageRange({
+        embedded: true,
+        globalDateRange: { start: "2026-07-14", end: "2026-08-17" },
+        hasLocalCostFilters: false,
+        period: defaultCostPeriod,
+        runPageRange: { from: "2026-07-14", to: "2026-08-17" },
+      }),
+    ).toEqual({ from: "2026-07-14", to: "2026-08-17" });
+    expect(
+      resolveCostGroupPageRange({
+        embedded: true,
+        globalDateRange: undefined,
+        hasLocalCostFilters: true,
+        period: defaultCostPeriod,
+        runPageRange: monthRange,
+      }),
+    ).toEqual(monthRange);
+  });
+
+  it("keeps compact SPEC and PRD pages and their export source on the all-time snapshot", () => {
+    const monthRange = costPeriodDateRange(defaultCostPeriod, new Date("2026-08-17T12:00:00.000Z"));
+    expect(
+      resolveCompactCostPageRange({
+        embedded: true,
+        globalDateRange: undefined,
+        hasLocalCostFilters: false,
+        period: defaultCostPeriod,
+        runPageRange: monthRange,
+      }),
+    ).toBeUndefined();
+    expect(
+      resolveCompactCostPageRange({
+        embedded: false,
+        globalDateRange: undefined,
+        hasLocalCostFilters: false,
+        period: defaultCostPeriod,
+        runPageRange: monthRange,
+      }),
+    ).toEqual(monthRange);
+    const page = readFileSync(new URL("./CostMonitorPage.tsx", import.meta.url), "utf8");
+    expect(page).toContain("range: compactPageRange");
+    expect(page).toContain("...(compactPageRange === undefined ? {} : compactPageRange)");
+  });
+
+  it("releases the host loading gate when a global filter replaces the Cost Monitor surface", () => {
+    const page = readFileSync(new URL("./CostMonitorPage.tsx", import.meta.url), "utf8");
+
+    expect(page).toContain("() => () => onLoadingChange?.(false)");
   });
 
   it("labels daily pagination by its continuous result range", () => {
-    expect(costGroupPageLabel({
-      locale: "pt-BR",
-      page: { offset: 30, limit: 30, total_count: 35 },
-    })).toBe("31–35 de 35");
+    expect(
+      costGroupPageLabel({
+        locale: "pt-BR",
+        page: { offset: 30, limit: 30, total_count: 35 },
+      }),
+    ).toBe("31–35 de 35");
     const content = readFileSync(new URL("./CostMonitorContent.tsx", import.meta.url), "utf8");
     expect(content).toContain("groupPageOffset + groupPage.limit");
     expect(content).toContain("groupPageOffset - groupPage.limit");
@@ -158,6 +207,8 @@ describe("cost monitor navigation", () => {
     const runHook = readFileSync(new URL("./use-cost-run-page.ts", import.meta.url), "utf8");
     const periodHook = readFileSync(new URL("./CostFilters.tsx", import.meta.url), "utf8");
     expect(compactHook).toContain("const loadRef = useRef(load)");
+    expect(compactHook).toContain("const [resolvedKey, setResolvedKey]");
+    expect(compactHook).toContain("compactPage: resolvedKey === requestKey ? page : null");
     expect(compactHook).toContain("const loadPage = loadRef.current");
     expect(compactHook).toContain("if (loadPage === undefined) return;");
     expect(compactHook).not.toContain("[attempt, load,");
@@ -198,11 +249,15 @@ describe("cost monitor navigation", () => {
     expect(isServerCostRunPagingEligible({ ...emptyCostFilters, status: "executing" })).toBe(true);
     expect(isServerCostRunPagingEligible({ ...emptyCostFilters, query: "edge" })).toBe(true);
     expect(isServerCostRunPagingEligible(emptyCostFilters, "edge")).toBe(true);
-    expect(isServerCostRunPagingEligible({ ...emptyCostFilters, query: "local" }, "global")).toBe(false);
+    expect(isServerCostRunPagingEligible({ ...emptyCostFilters, query: "local" }, "global")).toBe(
+      false,
+    );
   });
   it("routes global search to lazy invocations and all active dimensions to lazy groups", () => {
     expect(effectiveCostGroupQuery(emptyCostFilters, "global-edge")).toBe("global-edge");
-    expect(effectiveCostGroupQuery({ ...emptyCostFilters, query: "local-edge" }, "global-edge")).toBe("local-edge");
+    expect(
+      effectiveCostGroupQuery({ ...emptyCostFilters, query: "local-edge" }, "global-edge"),
+    ).toBe("local-edge");
     const page = readFileSync(new URL("./CostMonitorPage.tsx", import.meta.url), "utf8");
     const runHook = readFileSync(new URL("./use-cost-run-page.ts", import.meta.url), "utf8");
     const groupHook = readFileSync(new URL("./use-cost-group-page.ts", import.meta.url), "utf8");
@@ -272,6 +327,27 @@ describe("cost monitor navigation", () => {
     ]);
   });
 
+  it("prepares Agent Invocations from every server page for export", () => {
+    const page = readFileSync(new URL("./CostMonitorPage.tsx", import.meta.url), "utf8");
+    expect(page).toContain('view === "agentCalls" && serverPagingEligible');
+    expect(page).toContain("agentInvocationExportSource");
+    expect(page).toMatch(
+      /pageSource=\{\s*compactExportSource \?\? agentInvocationExportSource \?\? costGroupExportSource\s*\}/,
+    );
+    expect(page).toContain("if (page.runs.length === 0) return");
+  });
+
+  it("prepares every paginated period row for daily, monthly, and annual exports", () => {
+    const page = readFileSync(new URL("./CostMonitorPage.tsx", import.meta.url), "utf8");
+
+    expect(page).toContain('view === "daily" ||');
+    expect(page).toContain('view === "monthly" ||');
+    expect(page).toContain('view === "annual" ||');
+    expect(page).toContain("...(groupPageRange === undefined ? {} : groupPageRange)");
+    expect(page).toContain("totalRows: firstPage.total_count");
+    expect(page).toContain("nextOffset >= page.total_count || !page.has_more");
+  });
+
   it("resolves an Agent Run to its own details", () => {
     const runs = [{ id: "RUN-001" }, { id: "RUN-002" }];
 

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostMonitorPage.tsx

@@ -79,6 +79,11 @@ export type { LoadCostGroupPage } from "./use-cost-group-page.js";
 export type LoadCostMonitorDetail = typeof loadCostMonitorDetail;
 export type LoadCostRunPage = typeof loadCostMonitorRunPage;
 
+/** The overview is a summary surface, not an exportable table view. */
+export function isCostViewExportEligible(view: CostView): boolean {
+  return view !== "overview";
+}
+
 /**
  * The Cost period request filters Runs, while Operations is the global snapshot
  * used for shared entity detail. Keep the Executions tab on that same active
@@ -129,10 +134,20 @@ export function resolveCostGroupPageRange({
     globalDateRange === undefined &&
     period === defaultCostPeriod &&
     !hasLocalCostFilters
-  ) return undefined;
+  )
+    return undefined;
   return runPageRange;
 }
 
+/**
+ * Compact lifecycle tables share the embedded all-time snapshot contract with
+ * the group pager. In particular, the default month control is a display
+ * choice on that surface, not a hidden bound for SPEC/PRD rows or XLSX.
+ */
+export function resolveCompactCostPageRange(args: Parameters<typeof resolveCostGroupPageRange>[0]) {
+  return resolveCostGroupPageRange(args);
+}
+
 export function CostMonitorPage({
   capabilityNavigation,
   data,
@@ -234,6 +249,13 @@ export function CostMonitorPage({
     period,
     runPageRange,
   });
+  const compactPageRange = resolveCompactCostPageRange({
+    embedded,
+    globalDateRange: globalFilters?.dateRange,
+    hasLocalCostFilters,
+    period,
+    runPageRange,
+  });
   const costGroupViewName = (
     candidate: CostView,
   ): "daily" | "monthly" | "annual" | "agents" | "models" | "providers" | null =>
@@ -263,7 +285,7 @@ export function CostMonitorPage({
   } = useCompactCostPage({
     view,
     load: loadReadModelPage,
-    range: runPageRange,
+    range: compactPageRange,
     query: globalFilters?.query,
     filters,
   });
@@ -291,10 +313,29 @@ export function CostMonitorPage({
   useEffect(
     () =>
       onLoadingChange?.(
-        loading || periodLoading || runPageLoading || groupPageState.loading || compactPageLoading || detailLoading,
+        loading ||
+          periodLoading ||
+          runPageLoading ||
+          groupPageState.loading ||
+          compactPageLoading ||
+          detailLoading,
       ),
-    [compactPageLoading, detailLoading, groupPageState.loading, loading, onLoadingChange, periodLoading, runPageLoading],
+    [
+      compactPageLoading,
+      detailLoading,
+      groupPageState.loading,
+      loading,
+      onLoadingChange,
+      periodLoading,
+      runPageLoading,
+    ],
   );
+  // A global period/filter change deliberately unmounts this surface while it
+  // replaces the atomic Cost Monitor snapshot. Requests belonging to the old
+  // surface are aborted, so their normal completion path cannot clear the
+  // host-level loading gate. Always release that gate on unmount; the newly
+  // mounted surface will immediately assert its own loading state if needed.
+  useEffect(() => () => onLoadingChange?.(false), [onLoadingChange]);
   useEffect(() => {
     if (!hasLocalCostFilters) onActiveDataChange?.(activeData);
   }, [activeData, hasLocalCostFilters, onActiveDataChange]);
@@ -474,7 +515,10 @@ export function CostMonitorPage({
               groupPageState.page === null
                 ? []
                 : groupView === "agents"
-                  ? includeConfiguredAgentGroups(groupPageState.page.rows, activeData.configured_agents)
+                  ? includeConfiguredAgentGroups(
+                      groupPageState.page.rows,
+                      activeData.configured_agents,
+                    )
                   : [...groupPageState.page.rows],
           },
     [activeData.configured_agents, groups, groupPageState.page, groupView],
@@ -540,32 +584,134 @@ export function CostMonitorPage({
     visibleSpecs,
   ]);
   const compactExportSource =
-    usingCompactPage &&
-    compactKind !== null &&
-    compactPage !== null &&
-    loadReadModelPage !== undefined
+    usingCompactPage && compactKind !== null && loadReadModelPage !== undefined
+      ? {
+          prepare: async () => {
+            const firstPage = await loadReadModelPage({
+              kind: compactKind,
+              offset: 0,
+              limit: 50,
+              filters,
+              ...(compactPageRange === undefined ? {} : compactPageRange),
+              ...(globalFilters?.query ? { query: globalFilters.query } : {}),
+            });
+            return {
+              totalRows: firstPage.total,
+              pages: async function* () {
+                let page = firstPage;
+                const seen = new Set<string>();
+                while (true) {
+                  const unique = page.rows
+                    .filter((row) => {
+                      if (seen.has(row.id)) return false;
+                      seen.add(row.id);
+                      return true;
+                    })
+                    .map(withTokenBackedCompactDuration);
+                  if (unique.length > 0)
+                    yield unique as unknown as readonly Record<string, unknown>[];
+                  const nextOffset = page.offset + page.rows.length;
+                  if (nextOffset >= page.total || !page.has_more) return;
+                  page = await loadReadModelPage({
+                    kind: compactKind,
+                    offset: nextOffset,
+                    limit: page.limit,
+                    filters,
+                    ...(compactPageRange === undefined ? {} : compactPageRange),
+                    ...(globalFilters?.query ? { query: globalFilters.query } : {}),
+                  });
+                }
+              },
+            };
+          },
+        }
+      : undefined;
+  const agentInvocationExportSource =
+    view === "agentCalls" && serverPagingEligible && loadRunPage !== undefined
+      ? {
+          prepare: async () => {
+            const effectiveFilters = {
+              ...filters,
+              query: filters.query || globalFilters?.query || "",
+            };
+            const firstPage = await loadRunPage({
+              currency,
+              filters: effectiveFilters,
+              ...(runPageRange === undefined ? {} : runPageRange),
+              offset: 0,
+              refresh: lastUpdatedAt,
+            });
+            const totalRows = firstPage.run_page.total ?? firstPage.runs.length;
+            return {
+              totalRows,
+              pages: async function* () {
+                let page = firstPage;
+                while (true) {
+                  if (page.runs.length === 0) return;
+                  yield page.runs as unknown as readonly Record<string, unknown>[];
+                  const nextOffset = page.run_page.offset + page.runs.length;
+                  if (
+                    (page.run_page.total !== null && nextOffset >= page.run_page.total) ||
+                    !page.run_page.has_more
+                  )
+                    return;
+                  page = await loadRunPage({
+                    currency,
+                    filters: effectiveFilters,
+                    ...(runPageRange === undefined ? {} : runPageRange),
+                    offset: nextOffset,
+                    refresh: lastUpdatedAt,
+                  });
+                }
+              },
+            };
+          },
+        }
+      : undefined;
+  // Period views are paginated SQLite projections too.  Exporting their
+  // already-rendered group rows truncates the workbook to the visible page
+  // (and can lose the projection's factual duration).  Capture the same
+  // paged query used by the table so an All Time selection keeps its unbound
+  // range and every other selection retains its exact range and filters.
+  const costGroupExportSource =
+    (view === "daily" ||
+      view === "monthly" ||
+      view === "annual" ||
+      view === "agents" ||
+      view === "models" ||
+      view === "providers") &&
+    loadGroupPage !== undefined
       ? {
-          totalRows: compactPage.total,
-          pages: async function* () {
-            const seen = new Set<string>();
-            for (let offset = 0; offset < compactPage.total; offset += compactPage.limit) {
-              const page = await loadReadModelPage({
-                kind: compactKind,
-                offset,
-                limit: compactPage.limit,
-                filters,
-                ...(runPageRange === undefined ? {} : runPageRange),
-                ...(globalFilters?.query ? { query: globalFilters.query } : {}),
-              });
-              const unique = page.rows
-                .filter((row) => {
-                  if (seen.has(row.id)) return false;
-                  seen.add(row.id);
-                  return true;
-                })
-                .map(withTokenBackedCompactDuration);
-              if (unique.length > 0) yield unique as unknown as readonly Record<string, unknown>[];
-            }
+          prepare: async () => {
+            const query = filters.query || globalFilters?.query || "";
+            const firstPage = await loadGroupPage({
+              view,
+              offset: 0,
+              limit: 50,
+              filters,
+              ...(query ? { query } : {}),
+              ...(groupPageRange === undefined ? {} : groupPageRange),
+            });
+            return {
+              totalRows: firstPage.total_count,
+              pages: async function* () {
+                let page = firstPage;
+                while (true) {
+                  if (page.rows.length === 0) return;
+                  yield page.rows as unknown as readonly Record<string, unknown>[];
+                  const nextOffset = page.offset + page.rows.length;
+                  if (nextOffset >= page.total_count || !page.has_more) return;
+                  page = await loadGroupPage({
+                    view,
+                    offset: nextOffset,
+                    limit: page.limit,
+                    filters,
+                    ...(query ? { query } : {}),
+                    ...(groupPageRange === undefined ? {} : groupPageRange),
+                  });
+                }
+              },
+            };
           },
         }
       : undefined;
@@ -789,14 +935,18 @@ export function CostMonitorPage({
             </button>
           ))}
         </nav>
-        <div className="cost-tab-export">
-          <ExcelExportAction
-            filters={{ ...filters, ...globalFilters, period }}
-            {...(compactExportSource === undefined ? {} : { pageSource: compactExportSource })}
-            rows={exportRows as unknown as readonly Record<string, unknown>[]}
-            view={`cost-${view}`}
-          />
-        </div>
+        {isCostViewExportEligible(view) ? (
+          <div className="cost-tab-export">
+            <ExcelExportAction
+              filters={{ ...filters, ...globalFilters, period }}
+              pageSource={
+                compactExportSource ?? agentInvocationExportSource ?? costGroupExportSource
+              }
+              rows={exportRows as unknown as readonly Record<string, unknown>[]}
+              view={`cost-${view}`}
+            />
+          </div>
+        ) : null}
       </div>
       {/* CostMonitorContent owns `view === "models" && useAggregateGroups ? (` and `rows={groups.models}`. */}
       <CostMonitorContent

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostTables.test.ts

@@ -321,26 +321,58 @@ describe("grouped cost availability", () => {
       },
     });
     const columns = table.props.columns as Array<{ key: string; footer?: unknown }>;
-    expect((columns.find((column) => column.key === "tokens")?.footer as { props: { children: unknown } }).props.children).toBe("50");
-    expect((columns.find((column) => column.key === "cost")?.footer as { props: { children: unknown } }).props.children).toContain("20,00");
+    const tokenFooter = columns.find((column) => column.key === "tokens")?.footer;
+    const costFooter = columns.find((column) => column.key === "cost")?.footer;
+    expect(tokenFooter).toBeDefined();
+    expect(costFooter).toBeDefined();
+    expect((tokenFooter as { props: { children: unknown } }).props.children).toBe("50");
+    expect((costFooter as { props: { children: unknown } }).props.children).toContain("20,00");
   });
   it("renders ZAIP agent identity without a synthetic date column", () => {
     const table = CostGroupsTable({
-      rows: [{ ...unavailableGroup, key: "zaip-agent-builder", label: "zaip-agent-builder", persona: "Rafa", job: "Builder" }],
+      rows: [
+        {
+          ...unavailableGroup,
+          key: "zaip-agent-builder",
+          label: "zaip-agent-builder",
+          persona: "Rafa",
+          job: "Builder",
+        },
+      ],
       currency: "BRL",
       locale: "pt-BR",
       showDateTime: false,
       showAgentIdentity: true,
     });
-    const columns = table.props.columns as Array<{ key: string; label: string; hidden?: boolean; render?: (row: { persona?: string | null; job?: string | null }) => unknown }>;
+    const columns = table.props.columns as Array<{
+      key: string;
+      label: string;
+      hidden?: boolean;
+      render?: (row: { persona?: string | null; job?: string | null }) => unknown;
+    }>;
     expect(columns.find((column) => column.key === "latestStartedAt")?.hidden).toBe(true);
-    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: "Rafa" })).toBe("Rafa");
-    expect(columns.find((column) => column.key === "job")?.render?.({ job: "Builder" })).toBe("Builder");
+    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: "Rafa" })).toBe(
+      "Rafa",
+    );
+    expect(columns.find((column) => column.key === "job")?.render?.({ job: "Builder" })).toBe(
+      "Builder",
+    );
     expect(columns.find((column) => column.key === "tasks")).toBeUndefined();
+    expect(table.props.defaultSort).toEqual({ key: "cost", direction: "desc" });
   });
   it("keeps legacy codex identity fields blank and uses the complete paged aggregate in its footer", () => {
     const table = CostGroupsTable({
-      rows: [{ ...unavailableGroup, key: "codex", label: "codex", run_count: 1, total_tokens: 10, estimated_brl: 1, estimated_usd: 1 }],
+      rows: [
+        {
+          ...unavailableGroup,
+          key: "codex",
+          label: "codex",
+          run_count: 1,
+          total_tokens: 10,
+          estimated_brl: 1,
+          estimated_usd: 1,
+        },
+      ],
       currency: "BRL",
       locale: "pt-BR",
       showDateTime: false,
@@ -355,11 +387,19 @@ describe("grouped cost availability", () => {
         duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
       },
     });
-    const columns = table.props.columns as Array<{ key: string; render?: (row: { persona?: string | null; job?: string | null }) => unknown; footer?: unknown }>;
-    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: null })).toBe("");
+    const columns = table.props.columns as Array<{
+      key: string;
+      render?: (row: { persona?: string | null; job?: string | null }) => unknown;
+      footer?: unknown;
+    }>;
+    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: null })).toBe(
+      "",
+    );
     expect(columns.find((column) => column.key === "job")?.render?.({ job: null })).toBe("");
     expect(columns.find((column) => column.key === "runs")?.footer).toBe(2);
-    expect((columns.find((column) => column.key === "tokens")?.footer as { props: { children: unknown } }).props.children).toBe("30");
+    const tokenFooter = columns.find((column) => column.key === "tokens")?.footer;
+    expect(tokenFooter).toBeDefined();
+    expect((tokenFooter as { props: { children: unknown } }).props.children).toBe("30");
   });
   it("renders model groups without date and labels distinct invocation tasks", () => {
     const table = CostGroupsTable({
@@ -398,8 +438,9 @@ describe("grouped cost availability", () => {
       duration: { known_sum: 20_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
     };
     const table = CostGroupsTable({ rows: [partial], currency: "BRL", locale: "pt-BR" });
-    const duration = (table.props.columns as Array<{ key: string; footer?: { props: { children: unknown } } }>)
-      .find((column) => column.key === "duration");
+    const duration = (
+      table.props.columns as Array<{ key: string; footer?: { props: { children: unknown } } }>
+    ).find((column) => column.key === "duration");
     expect(duration?.footer?.props.children).toBe("20 seg");
   });
   it("does not expose coverage as a detailed Run column", () => {
@@ -470,11 +511,28 @@ describe("grouped cost availability", () => {
     }>;
     const column = (key: string) => columns.find((candidate) => candidate.key === key);
     const numericKeys = [
-      "duration", "inputTokens", "cachedInputTokens", "outputTokens", "reasoningTokens",
-      "totalTokens", "inputRate", "cacheRate",
-      "outputRate", "reasoningRate", "contextMultiplier", "inputCost", "cacheCost",
-      "outputCost", "reasoningCost", "standardCost", "speedUplift", "finalUsd", "fxRate",
-      "recordedFxRate", "recordedBrl", "cost",
+      "duration",
+      "inputTokens",
+      "cachedInputTokens",
+      "outputTokens",
+      "reasoningTokens",
+      "totalTokens",
+      "inputRate",
+      "cacheRate",
+      "outputRate",
+      "reasoningRate",
+      "contextMultiplier",
+      "inputCost",
+      "cacheCost",
+      "outputCost",
+      "reasoningCost",
+      "standardCost",
+      "speedUplift",
+      "finalUsd",
+      "fxRate",
+      "recordedFxRate",
+      "recordedBrl",
+      "cost",
     ];
     for (const key of numericKeys) {
       expect(column(key)?.description).toContain("projeção SQLite/API");