@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -5,6 +5,7 @@ import {
   activeCostPeriodData,
   costPeriodDateRange,
   defaultCostPeriod,
+  emptyCostFilters,
   loadCostMonitorPeriod,
   shouldFetchCostPeriod,
 } from "./CostFilters.js";
@@ -17,7 +18,9 @@ import {
   costGroupsScrollLabel,
   costPeriodTotalAriaLabel,
   costRunsDurationTotal,
+  costRunsFooterLabel,
   costRunsScrollLabel,
+  displayCostGroupLabel,
   formatAuditableCompactNumber,
   formatAuditableCurrency,
   formatAuditableDuration,
@@ -30,6 +33,7 @@ import {
   formatRate,
   formatReasoningEffort,
   formatServiceTier,
+  formatTokenBackedDuration,
   formatUsd,
   hasCollectedUsage,
   isCompactRunColumnVisible,
@@ -49,7 +53,6 @@ describe("Agent Run model presentation", () => {
       }),
     ).toEqual({ primary: "gpt-5.6-sol", detail: "openai" });
   });
-
   it("does not mention an unavailable planned configuration", () => {
     expect(
       agentRunModelPresentation({
@@ -63,7 +66,6 @@ describe("Agent Run model presentation", () => {
     });
   });
 });
-
 describe("period formatting", () => {
   it("renders daily dates and keeps monthly periods numerically sortable", () => {
     expect(formatCostPeriodLabel("2026-07-16", "daily", "pt-BR")).toBe("16/07/2026");
@@ -72,7 +74,6 @@ describe("period formatting", () => {
     expect(formatCostPeriodLabel("2026", "annual", "pt-BR")).toBe("2026");
   });
 });
-
 describe("period total accessibility", () => {
   it("names the complete period total with the displayed time, tokens, and BRL values", () => {
     expect(
@@ -86,7 +87,13 @@ describe("period total accessibility", () => {
     ).toBe("Total geral — Tempo: 2h 15min; Tokens: 1,2 mi; BRL: R$ 3,40");
   });
 });
-
+describe("incremental Run table labels", () => {
+  it("does not present a paged subset as the complete Run total", () => {
+    expect(costRunsFooterLabel("pt-BR", true)).toBe("Subtotal da página");
+    expect(costRunsFooterLabel("en-US", true)).toBe("Page subtotal");
+    expect(costRunsFooterLabel("pt-BR", false)).toBe("Total");
+  });
+});
 describe("Run origin badges", () => {
   it("uses one hierarchical origin per Run", () => {
     expect(runOriginBadge({ prd_id: "PRD-1", spec_id: "SPEC-1", task_id: "TASK-1" })).toEqual({
@@ -103,25 +110,21 @@ describe("Run origin badges", () => {
     });
   });
 });
-
 describe("date time formatting", () => {
   it("uses a placeholder for groups that do not yet have a Run", () => {
     expect(formatDateTime("", "pt-BR")).toBe("—");
   });
 });
-
 describe("formatAuditableNumber", () => {
-  it("keeps unavailable numeric metrics distinct from observed zero", () => {
-    expect(formatAuditableNumber(null, "pt-BR")).toBe("Indisponível");
-    expect(formatAuditableNumber(null, "en-US")).toBe("Unavailable");
+  it("renders unavailable numeric metrics as presentation zero", () => {
+    expect(formatAuditableNumber(null, "pt-BR")).toBe("0");
+    expect(formatAuditableNumber(null, "en-US")).toBe("0");
     expect(formatAuditableNumber(0, "pt-BR")).toBe("0");
   });
-
   it("keeps observed positive values", () => {
     expect(formatAuditableNumber(1234, "pt-BR")).toBe("1.234");
   });
 });
-
 describe("compact Sub-Run columns", () => {
   it("keeps a column hidden until at least one Sub-Run has observed data", () => {
     const rows = [{ duration_ms: null }, { duration_ms: null }] as never;
@@ -134,38 +137,38 @@ describe("compact Sub-Run columns", () => {
     ).toBe(true);
   });
 });
-
 describe("monetary formatting", () => {
   it("uses exactly two decimal places for rates and USD totals", () => {
     expect(formatRate(5.450000053204, "pt-BR")).toBe("5,45");
     expect(formatBrlRate(5.450000053204, "pt-BR")).toBe("R$ 5,45");
     expect(formatUsd(19.583447, "pt-BR").replace(/\s/g, " ")).toBe("US$ 19,58");
   });
-
   it("calculates exchange as a direct BRL/USD ratio", () => {
     expect(ratio(106.73, 19.583444)).toBeCloseTo(5.45, 2);
     expect(ratio(100, 0)).toBeNull();
   });
-
-  it("keeps unavailable duration distinct from an observed zero", () => {
-    expect(formatRate(null, "pt-BR")).toBe("Indisponível");
-    expect(formatUsd(null, "en-US")).toBe("Unavailable");
-    expect(formatAuditableCurrency(null, "BRL", "pt-BR")).toBe("Indisponível");
+  it("renders unavailable numeric metrics as zero", () => {
+    expect(formatRate(null, "pt-BR")).toBe("0,00");
+    expect(formatUsd(null, "en-US")).toContain("0.00");
+    expect(formatAuditableCurrency(null, "BRL", "pt-BR")).toContain("0,00");
     expect(formatAuditableDuration(null, "pt-BR")).toBe("Indisponível");
-    expect(formatAuditableCompactNumber(null, "pt-BR")).toBe("Indisponível");
-    expect(formatMultiplierPair(null, null, "pt-BR")).toBe("Indisponível");
-    expect(formatMultiplierPair(2, null, "pt-BR")).toBe("Indisponível");
+    expect(formatAuditableCompactNumber(null, "pt-BR")).toBe("0");
   });
 });
-
 describe("duration coverage", () => {
-  it("renders known partial duration without claiming it is complete", () => {
+  it("renders the factual known duration while preserving partial coverage", () => {
     expect(
       formatDurationCoverage(
         { known_sum: 60_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
         "pt-BR",
       ),
     ).toBe("1 min");
+    expect(
+      formatDurationCoverage(
+        { known_sum: 600_705_381, unknown: 14, complete: false, coverage_ratio: 34 / 48 },
+        "pt-BR",
+      ),
+    ).toBe("166,9 h");
     expect(
       formatDurationCoverage(
         { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
@@ -173,15 +176,29 @@ describe("duration coverage", () => {
       ),
     ).toBe("Indisponível");
   });
+  it("does not treat financial tokens as elapsed-time evidence", () => {
+    expect(
+      formatTokenBackedDuration(
+        { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+        1_100,
+        "pt-BR",
+      ),
+    ).toBe(formatAuditableDuration(null, "pt-BR"));
+    expect(
+      formatTokenBackedDuration(
+        { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+        null,
+        "pt-BR",
+      ),
+    ).toBe(formatAuditableDuration(null, "pt-BR"));
+  });
 });
-
 describe("runtime availability", () => {
   it("uses requested effort only as a clearly labelled visual fallback", () => {
     expect(formatReasoningEffort("high", "medium", "pt-BR")).toBe("Alto");
     expect(formatReasoningEffort(null, "high", "pt-BR")).toBe("Alto (solicitado; efetivo -)");
     expect(formatReasoningEffort(null, null, "en-US")).toBe("-");
   });
-
   it("uses the default speed label when the service tier is unavailable", () => {
     expect(formatServiceTier(null, "pt-BR")).toBe("Padrão");
     expect(formatServiceTier("unknown", "pt-BR")).toBe("Padrão");
@@ -189,7 +206,6 @@ describe("runtime availability", () => {
     expect(formatServiceTier("priority", "pt-BR")).toBe("Rápido");
   });
 });
-
 describe("grouped cost availability", () => {
   it("uses deduplicated root and child invocation effort in the Run drilldown footer", () => {
     const root = {
@@ -224,7 +240,35 @@ describe("grouped cost availability", () => {
     duration: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
     coverage: { events: 2, tokens: 0, usd: 0, brl: 0 },
   } as const;
-
+  it.each([
+    "daily",
+    "monthly",
+    "annual",
+  ] as const)("matches the Operations column order for %s summaries", (period) => {
+    const table = CostGroupsTable({
+      rows: [unavailableGroup],
+      currency: "BRL",
+      locale: "pt-BR",
+      period,
+    });
+    const columns = table.props.columns as Array<{ key: string; label: string }>;
+    expect(
+      columns
+        .filter((column) => column.key !== "latestStartedAt")
+        .map((column) => [column.key, column.label]),
+    ).toEqual([
+      ["label", period === "daily" ? "Dia" : period === "monthly" ? "Mês" : "Ano"],
+      ["prds", "PRDs"],
+      ["specs", "SPECs"],
+      ["tasks", "Tarefas criadas"],
+      ["runs", "Runs"],
+      ["tests", "Testes"],
+      ["evidences", "Evidências"],
+      ["duration", "Tempo"],
+      ["tokens", "Tokens"],
+      ["cost", "Custos"],
+    ]);
+  });
   it("renders unavailable duration explicitly and keeps the accessible scroll region", () => {
     const table = CostGroupsTable({
       rows: [unavailableGroup],
@@ -238,16 +282,14 @@ describe("grouped cost availability", () => {
       footer?: unknown;
     }>;
     const column = (key: string) => columns.find((candidate) => candidate.key === key);
-
     expect(table.props.scrollLabel).toBe(costGroupsScrollLabel("pt-BR"));
     expect(column("duration")?.render(unavailableGroup)).toBe("Indisponível");
-    expect(column("tokens")?.render(unavailableGroup)).toBe("Indisponível");
-    expect(column("cost")?.render(unavailableGroup)).toBe("Indisponível");
+    expect(column("tokens")?.render(unavailableGroup)).toBe("0");
+    expect(column("cost")?.render(unavailableGroup)).toContain("0,00");
     expect(column("duration")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("tokens")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("cost")?.sortValue?.(unavailableGroup)).toBeNull();
-    const totalSummary =
-      "Total geral — Tempo: Indispon\u00edvel; Tokens: Indispon\u00edvel; BRL: Indispon\u00edvel";
+    const totalSummary = "Total geral — Tempo: Indisponível; Tokens: 0; BRL: R$ 0,00";
     expect(
       (column("latestStartedAt")!.footer as { props: { "aria-label": string } }).props[
         "aria-label"
@@ -264,7 +306,113 @@ describe("grouped cost availability", () => {
     ).toBe(totalSummary);
     expect(column("coverage")).toBeUndefined();
   });
-
+  it("uses supplied pre-pagination totals for daily footer metrics", () => {
+    const table = CostGroupsTable({
+      rows: [{ ...unavailableGroup, total_tokens: 5, estimated_brl: 2, estimated_usd: 1 }],
+      currency: "BRL",
+      locale: "pt-BR",
+      period: "daily",
+      totals: {
+        ...unavailableGroup,
+        total_tokens: 50,
+        estimated_brl: 20,
+        estimated_usd: 10,
+        duration: { known_sum: 600_000, unknown: 0, complete: true, coverage_ratio: 1 },
+      },
+    });
+    const columns = table.props.columns as Array<{ key: string; footer?: unknown }>;
+    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",
+        },
+      ],
+      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;
+    }>;
+    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 === "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,
+        },
+      ],
+      currency: "BRL",
+      locale: "pt-BR",
+      showDateTime: false,
+      showAgentIdentity: true,
+      totals: {
+        ...unavailableGroup,
+        run_count: 2,
+        task_count: 2,
+        total_tokens: 30,
+        estimated_brl: 3,
+        estimated_usd: 3,
+        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(
+      "",
+    );
+    expect(columns.find((column) => column.key === "job")?.render?.({ job: null })).toBe("");
+    expect(columns.find((column) => column.key === "runs")?.footer).toBe(2);
+    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({
+      rows: [{ ...unavailableGroup, key: "unavailable", label: "unavailable", task_count: 0 }],
+      currency: "BRL",
+      locale: "pt-BR",
+      showDateTime: false,
+      showInvocationTasks: true,
+    });
+    const columns = table.props.columns as Array<{ key: string; label: string; hidden?: boolean }>;
+    expect(columns.find((column) => column.key === "latestStartedAt")?.hidden).toBe(true);
+    expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tarefas com invocação");
+  });
   it("keeps a complete observed zero visible without a partial coverage label", () => {
     const observedZeroGroup = {
       ...unavailableGroup,
@@ -279,11 +427,22 @@ describe("grouped cost availability", () => {
         footer?: { props: { children: unknown } };
       }>
     ).find((column) => column.key === "duration");
-
     expect(duration?.render(observedZeroGroup)).toBe(formatAuditableDuration(0, "pt-BR"));
     expect(duration?.footer?.props.children).toBe(formatAuditableDuration(0, "pt-BR"));
   });
-
+  it("presents the factual known portion of a partial duration subtotal", () => {
+    const partial = {
+      ...unavailableGroup,
+      total_tokens: 1_000,
+      duration_ms: null,
+      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");
+    expect(duration?.footer?.props.children).toBe("20 seg");
+  });
   it("does not expose coverage as a detailed Run column", () => {
     const table = CostRunsTable({
       rows: [unavailableGroup] as never,
@@ -294,7 +453,6 @@ describe("grouped cost availability", () => {
     const columns = table.props.columns as Array<{ key: string }>;
     expect(columns.some((column) => column.key === "coverage")).toBe(false);
   });
-
   it("sorts unavailable Run numeric metrics as unavailable", () => {
     const unavailableRun = { ...unavailableGroup, input_tokens: null, output_tokens: null };
     const table = CostRunsTable({
@@ -308,28 +466,169 @@ describe("grouped cost availability", () => {
       sortValue?: (row: typeof unavailableGroup) => unknown;
     }>;
     const column = (key: string) => columns.find((candidate) => candidate.key === key);
-
     expect(column("duration")?.sortValue?.(unavailableRun)).toBeNull();
     expect(column("totalTokens")?.sortValue?.(unavailableRun)).toBeNull();
     expect(column("cost")?.sortValue?.(unavailableRun)).toBeNull();
   });
-
+  it("keeps missing invocation facts unavailable instead of presenting observed zero", () => {
+    const unavailableRun = {
+      ...unavailableGroup,
+      input_tokens: null,
+      cached_input_tokens: null,
+      uncached_input_tokens: null,
+      output_tokens: null,
+      reasoning_tokens: null,
+      visible_output_tokens: null,
+      input_rate_usd_per_million: null,
+      cached_input_rate_usd_per_million: null,
+      output_rate_usd_per_million: null,
+      reasoning_rate_usd_per_million: null,
+      context_input_multiplier: null,
+      context_output_multiplier: null,
+      input_cost_usd: null,
+      cached_input_cost_usd: null,
+      output_cost_usd: null,
+      reasoning_cost_usd: null,
+      standard_cost_usd: null,
+      speed_uplift_usd: null,
+      fx_rate: null,
+      recorded_fx_rate: null,
+      recorded_brl: null,
+      estimated_usd: null,
+      estimated_brl: null,
+    } as never;
+    const table = CostRunsTable({
+      rows: [unavailableRun],
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      description?: string;
+      hidden?: boolean;
+      render?: (row: typeof unavailableRun) => unknown;
+    }>;
+    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",
+    ];
+    for (const key of numericKeys) {
+      expect(column(key)?.description).toContain("projeção SQLite/API");
+      expect(column(key)?.hidden).not.toBe(true);
+    }
+    expect(column("duration")?.render?.(unavailableRun)).toBe("Indisponível");
+    expect(column("inputTokens")?.render?.(unavailableRun)).toBe("0");
+    expect(column("inputRate")?.render?.(unavailableRun)).toBe("0,00");
+    expect(column("contextMultiplier")?.render?.(unavailableRun)).toBe("Indisponível");
+    expect(column("inputCost")?.render?.(unavailableRun)).toContain("0,00");
+    expect(column("fxRate")?.render?.(unavailableRun)).toBe("R$ 0,00");
+    expect(column("recordedBrl")?.render?.(unavailableRun)).toContain("0,00");
+    expect(column("cost")?.render?.(unavailableRun)).toContain("0,00");
+  });
   it("provides a clear scroll label for the detailed Runs table", () => {
     expect(costRunsScrollLabel("pt-BR")).toBe(
       "Tabela de custos por invocação com rolagem horizontal",
     );
   });
-});
+  it("presents inclusive input/output totals and only their cache/reasoning subsets", () => {
+    const run = {
+      ...unavailableGroup,
+      input_tokens: 1_000,
+      cached_input_tokens: 200,
+      output_tokens: 500,
+      reasoning_tokens: 100,
+      total_tokens: 1_700,
+    } as never;
+    const table = CostRunsTable({
+      rows: [run],
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      label?: string;
+      sortValue?: (row: typeof run) => unknown;
+    }>;
+    const column = (key: string) => columns.find((candidate) => candidate.key === key);
 
+    expect(column("inputTokens")?.label).toBe("Input total");
+    expect(column("outputTokens")?.label).toBe("Output total");
+    expect(column("uncachedInputTokens")).toBeUndefined();
+    expect(column("visibleOutputTokens")).toBeUndefined();
+    expect(column("totalTokens")?.sortValue?.(run)).toBe(1_500);
+  });
+  it("uses server pagination without re-applying the visual 100-row truncation", () => {
+    const table = CostRunsTable({
+      rows: [unavailableGroup] as never,
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+      pagination: {
+        offset: 100,
+        limit: 100,
+        total: 250,
+        has_more: true,
+        loading: false,
+        error: null,
+        onChange: () => undefined,
+        onRetry: () => undefined,
+      },
+    });
+    expect(table.type).toBe(Symbol.for("react.fragment"));
+    expect(table.props.children[0].props.pageSize).toBeNull();
+  });
+  it("keeps an initial server-page error actionable before a page exists", () => {
+    const table = CostRunsTable({
+      rows: [unavailableGroup] as never,
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+      pagination: {
+        offset: 0,
+        limit: 100,
+        total: 1,
+        has_more: false,
+        loading: false,
+        error: "network failed",
+        onChange: () => undefined,
+        onRetry: () => undefined,
+      },
+    });
+    const pager = table.props.children[1];
+    expect(pager.props.pagination.error).toBe("network failed");
+    expect(pager.props.pagination.onRetry).toEqual(expect.any(Function));
+  });
+});
 describe("period-driven Cost Monitor loading", () => {
   it("drops a stale in-memory Cost period response when refresh replaces its base snapshot", () => {
     const stale = { runs: [{ run_id: "RUN-OBSERVED", duration_ms: 31 * 3_600_000 }] } as never;
     const refreshed = { runs: [{ run_id: "RUN-PROJECTED", duration_ms: 413_659_026 }] } as never;
-
     expect(activeCostPeriodData(refreshed, stale, stale)).toBe(refreshed);
     expect(activeCostPeriodData(refreshed, refreshed, refreshed)).toBe(refreshed);
   });
-
   it("does not issue a second Cost request after an embedded default atomic snapshot", () => {
     const filters = {
       query: "",
@@ -343,26 +642,25 @@ describe("period-driven Cost Monitor loading", () => {
       priority: "",
       risk: "",
     };
-    expect(shouldFetchCostPeriod({ filters, period: "all", snapshotBacked: true })).toBe(false);
+    expect(shouldFetchCostPeriod({ filters, period: "month", snapshotBacked: true })).toBe(false);
+    expect(shouldFetchCostPeriod({ filters, period: "all", snapshotBacked: true })).toBe(true);
     expect(shouldFetchCostPeriod({ filters, period: "7", snapshotBacked: true })).toBe(true);
     expect(
       shouldFetchCostPeriod({
         filters: { ...filters, phase: "execution" },
-        period: "all",
+        period: "month",
         snapshotBacked: true,
       }),
     ).toBe(true);
   });
-
-  it("uses no date bounds for the default complete-history period", async () => {
-    expect(defaultCostPeriod).toBe("all");
+  it("uses the current month for the default period and keeps All Time explicit", async () => {
+    expect(defaultCostPeriod).toBe("month");
     expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
     expect(costPeriodDateRange("month", new Date("2026-08-01T03:30:00.000Z"))).toEqual({
       from: "2026-08-01",
       to: "2026-08-01",
     });
-    // Resetting standalone Cost Monitor to All Time removes the prior month
-    // bounds instead of carrying them into the next request.
+    // Selecting standalone All Time still removes the prior month bounds.
     expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
     const calls: string[] = [];
     await loadCostMonitorPeriod({
@@ -372,9 +670,8 @@ describe("period-driven Cost Monitor loading", () => {
         return new Response(JSON.stringify({ runs: [] }), { status: 200 });
       },
     });
-    expect(calls).toEqual(["/api/v2/cost-monitor?currency=BRL"]);
+    expect(calls).toEqual(["/api/v2/cost-monitor?currency=BRL&scope=summary"]);
   });
-
   it("derives an inclusive current-month range without inspecting materialized Runs", () => {
     expect(costPeriodDateRange("month", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
       from: "2026-07-01",
@@ -385,7 +682,6 @@ describe("period-driven Cost Monitor loading", () => {
       to: "2026-07-26",
     });
   });
-
   it("requests the selected range from the local runtime and forwards cancellation", async () => {
     const calls: Array<{ url: string; signal: AbortSignal | null | undefined }> = [];
     const controller = new AbortController();
@@ -415,20 +711,32 @@ describe("period-driven Cost Monitor loading", () => {
         });
       },
     });
-
     expect(loaded).toEqual(projection);
     expect(calls).toEqual([
       {
         url:
-          "/api/v2/cost-monitor?currency=BRL&from=2026-07-01&to=2026-07-26" +
+          "/api/v2/cost-monitor?currency=BRL&scope=summary&from=2026-07-01&to=2026-07-26" +
           "&provider=openai&phase=execution&agent=zaip-agent-builder" +
           "&model=gpt-5.6-terra&status=completed",
         signal: controller.signal,
       },
     ]);
   });
+  it("never leaves period/filter hydration scope-less or on detail", async () => {
+    const calls: string[] = [];
+    await loadCostMonitorPeriod({
+      currency: "USD",
+      filters: { ...emptyCostFilters, provider: "openai", model: "gpt-5.6-terra" },
+      fetcher: async (url) => {
+        calls.push(String(url));
+        return new Response(JSON.stringify({ runs: [] }), { status: 200 });
+      },
+    });
+    const request = new URL(calls[0]!, "http://dashboard.local");
+    expect(request.searchParams.get("scope")).toBe("summary");
+    expect(request.searchParams.get("scope")).not.toBe("detail");
+  });
 });
-
 describe("manifest-first invocation query", () => {
   it("opens only intersecting monthly manifests and candidate chunks", async () => {
     const inRange = signedSummary({
@@ -495,7 +803,6 @@ describe("manifest-first invocation query", () => {
         filters: { providers: ["openai"] },
       },
     );
-
     expect(result.summaries.map((summary) => summary.agent_invocation_id)).toEqual([
       "RUN-JULY-OPENAI",
     ]);
@@ -509,11 +816,9 @@ describe("manifest-first invocation query", () => {
     ]);
   });
 });
-
 function digest(value: string): string {
   return createHash("sha256").update(value).digest("hex");
 }
-
 function dimensions(overrides: Partial<Record<string, readonly string[]>> = {}) {
   return {
     providers: [],
@@ -530,7 +835,6 @@ function dimensions(overrides: Partial<Record<string, readonly string[]>> = {})
     ...overrides,
   };
 }
-
 function signedSummary(input: {
   agent_invocation_id: string;
   occurred_at: string;
@@ -545,7 +849,6 @@ function signedSummary(input: {
   };
   return { ...unsigned, summary_hash: digest(JSON.stringify(unsigned)) };
 }
-
 function signedManifest(input: {
   period: { year: number; month: number };
   from: string;
@@ -582,11 +885,9 @@ function signedManifest(input: {
   };
   return { ...unsigned, manifest_hash: digest(JSON.stringify(unsigned)) };
 }
-
 describe("cost sorting", () => {
   it("orders the raw BRL values rather than their localized currency labels", () => {
     const rows = [143.72, 127.78, 21457.76, 1370.63];
-
     expect(
       rows.sort(
         (left, right) =>
@@ -595,7 +896,6 @@ describe("cost sorting", () => {
     ).toEqual([21457.76, 1370.63, 143.72, 127.78]);
   });
 });
-
 describe("context uplift", () => {
   const base = {
     context_input_multiplier: 1,
@@ -605,11 +905,9 @@ describe("context uplift", () => {
     output_cost_usd: 8,
     reasoning_cost_usd: 2,
   };
-
   it("returns zero for a 1x / 1x call", () => {
     expect(contextUpliftUsd(base as never)).toBe(0);
   });
-
   it("extracts the already included context portion from effective costs", () => {
     expect(
       contextUpliftUsd({
@@ -620,7 +918,6 @@ describe("context uplift", () => {
     ).toBeCloseTo(9.333333, 5);
   });
 });
-
 describe("model aggregation visibility", () => {
   it("hides the manual placeholder regardless of casing or whitespace", () => {
     expect(isDisplayableModel("manual")).toBe(false);
@@ -632,7 +929,6 @@ describe("model aggregation visibility", () => {
     expect(isDisplayableModel("gpt-5.4")).toBe(true);
     expect(isDisplayableModel("gpt-5.6-sol")).toBe(true);
   });
-
   it("hides calls that have no collected usage", () => {
     const empty = {
       input_tokens: null,
@@ -648,7 +944,6 @@ describe("model aggregation visibility", () => {
     expect(hasCollectedUsage({ ...empty, estimated_brl: 0.01 } as never)).toBe(true);
   });
 });
-
 describe("model processing duration", () => {
   it("sums root orchestration Runs without overlapping intake and Sub-Runs", () => {
     expect(
@@ -666,15 +961,18 @@ describe("model processing duration", () => {
       ]),
     ).toBe(210_000);
   });
-
-  it("groups Runs without an identifiable model as Undefined", () => {
+  it("groups Runs without an identifiable model as unavailable", () => {
     expect(displayModelName("gpt-5.6-sol", "pt-BR")).toBe("gpt-5.6-sol");
-    expect(displayModelName("unknown", "pt-BR")).toBe("Indefinido");
-    expect(displayModelName(" ", "en-US")).toBe("Undefined");
+    expect(displayModelName("unknown", "pt-BR")).toBe("Indisponível");
+    expect(displayModelName(" ", "en-US")).toBe("Unavailable");
     expect(displayModelName("manual", "pt-BR")).toBeNull();
     expect(displayModelName("gpt-5", "pt-BR")).toBeNull();
   });
-
+  it("presents genuinely missing aggregate dimensions as unavailable", () => {
+    expect(displayCostGroupLabel("unknown", "pt-BR")).toBe("Sem modelo/provedor atribuído");
+    expect(displayCostGroupLabel(" ", "en-US")).toBe("No model/provider assigned");
+    expect(displayCostGroupLabel("gpt-5.6-sol", "pt-BR")).toBe("gpt-5.6-sol");
+  });
   it("keeps duration-only root orchestration Runs in the model table", () => {
     expect(
       isModelAuditRow({