@zaip-ai/cli 1.3.0 → 1.3.1

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

@@ -1,17 +1,11 @@
 import { createHash } from "node:crypto";
 import { queryInvocationManifestPeriod } from "@zaip-ai/costs";
 import { describe, expect, it } from "vitest";
-import {
-  activeCostPeriodData,
-  costPeriodDateRange,
-  defaultCostPeriod,
-  emptyCostFilters,
-  loadCostMonitorPeriod,
-  shouldFetchCostPeriod,
-} from "./CostFilters.js";
 import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
 import {
   agentRunModelPresentation,
+  type CostDeveloperAttributionRow,
+  CostDeveloperAttributionTable,
   CostGroupsTable,
   CostRunsTable,
   contextUpliftUsd,
@@ -29,7 +23,6 @@ import {
   formatCostPeriodLabel,
   formatDateTime,
   formatDurationCoverage,
-  formatMultiplierPair,
   formatRate,
   formatReasoningEffort,
   formatServiceTier,
@@ -207,6 +200,112 @@ describe("runtime availability", () => {
   });
 });
 describe("grouped cost availability", () => {
+  it("uses the requested Cost Monitor developer metric columns without Operations source or coverage", () => {
+    const table = CostDeveloperAttributionTable({
+      locale: "pt-BR",
+      rows: [
+        {
+          account_id: "42",
+          login_snapshot: "dev-42",
+          prd_count: 1,
+          spec_count: 2,
+          task_count: 3,
+          run_count: 4,
+          test_count: null,
+          evidence_count: null,
+          total_duration_ms: 60_000,
+          total_tokens: 50,
+          total_cost_brl: 1.5,
+          duration_covered_runs: 4,
+          token_covered_runs: 4,
+          brl_covered_runs: 4,
+        },
+      ],
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      label: string;
+      render: (row: CostDeveloperAttributionRow) => unknown;
+    }>;
+    const unavailable = {
+      account_id: "unknown",
+      login_snapshot: null,
+      prd_count: 0,
+      spec_count: 0,
+      task_count: 0,
+      run_count: 0,
+      test_count: null,
+      evidence_count: null,
+      total_duration_ms: null,
+      total_tokens: null,
+      total_cost_brl: null,
+      duration_covered_runs: 0,
+      token_covered_runs: 0,
+      brl_covered_runs: 0,
+    } satisfies CostDeveloperAttributionRow;
+    expect(columns.map((column) => [column.key, column.label])).toEqual([
+      ["developer", "Desenvolvedor"],
+      ["prds", "PRDs"],
+      ["specs", "SPECs"],
+      ["tasks", "Tarefas"],
+      ["runs", "Runs"],
+      ["tests", "Testes"],
+      ["evidences", "Evidências"],
+      ["duration", "Tempo"],
+      ["tokens", "Tokens"],
+      ["cost", "Custos"],
+    ]);
+    expect(columns.find((column) => column.key === "tests")?.render(unavailable)).toBe("—");
+    expect(columns.find((column) => column.key === "evidences")?.render(unavailable)).toBe("—");
+    expect(columns.find((column) => column.key === "duration")?.render(unavailable)).toBe(
+      "Indisponível",
+    );
+  });
+  it("marks incomplete aggregates in place without adding source or coverage columns", () => {
+    const partial = {
+      account_id: "42",
+      login_snapshot: "dev-42",
+      prd_count: 1,
+      spec_count: 2,
+      task_count: 3,
+      run_count: 4,
+      test_count: null,
+      evidence_count: null,
+      total_duration_ms: 60_000,
+      total_tokens: 50,
+      total_cost_brl: 1.5,
+      duration_covered_runs: 3,
+      token_covered_runs: 2,
+      brl_covered_runs: 2,
+    } satisfies CostDeveloperAttributionRow;
+    const table = CostDeveloperAttributionTable({ locale: "pt-BR", rows: [partial] });
+    const columns = table.props.columns as Array<{
+      key: string;
+      render: (
+        row: CostDeveloperAttributionRow,
+      ) => { props?: { children?: unknown[]; title?: string } } | string;
+    }>;
+    for (const key of ["duration", "tokens", "cost"]) {
+      const rendered = columns.find((column) => column.key === key)?.render(partial);
+      expect(rendered).toMatchObject({
+        props: {
+          title: expect.stringContaining("Valor parcial"),
+        },
+      });
+      const children = (rendered as { props: { children: unknown[] } }).props.children;
+      expect(children[0]).toMatchObject({
+        props: { "aria-hidden": "true", children: expect.any(String) },
+      });
+      expect(children[1]).toMatchObject({
+        props: { children: expect.stringContaining("Valor parcial") },
+      });
+      expect(
+        (rendered as { props: { "aria-label"?: string } }).props["aria-label"],
+      ).toBeUndefined();
+    }
+    expect(columns.map((column) => column.key)).not.toContain("coverage");
+    expect(columns.map((column) => column.key)).not.toContain("source");
+  });
   it("uses deduplicated root and child invocation effort in the Run drilldown footer", () => {
     const root = {
       run_id: "RUN-ROOT",
@@ -290,22 +389,28 @@ describe("grouped cost availability", () => {
     expect(column("tokens")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("cost")?.sortValue?.(unavailableGroup)).toBeNull();
     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"
-      ],
-    ).toBe("Total geral");
-    expect(
-      (column("duration")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
-    expect(
-      (column("tokens")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
-    expect(
-      (column("cost")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
+    const footerLabel = (key: string) => {
+      const footer = column(key)?.footer as { props?: { "aria-label"?: string } } | undefined;
+      return footer?.props?.["aria-label"];
+    };
+    expect(footerLabel("latestStartedAt")).toBe("Total geral");
+    expect(footerLabel("duration")).toBe(totalSummary);
+    expect(footerLabel("tokens")).toBe(totalSummary);
+    expect(footerLabel("cost")).toBe(totalSummary);
     expect(column("coverage")).toBeUndefined();
   });
+  it("keeps the empty state until loading settles for local cost-group pages", () => {
+    const loadingTable = CostGroupsTable({
+      rows: [],
+      currency: "BRL",
+      locale: "pt-BR",
+      loading: true,
+    });
+    const emptyTable = CostGroupsTable({ rows: [], currency: "BRL", locale: "pt-BR" });
+
+    expect(loadingTable.props.emptyMessage).toBe("Carregando…");
+    expect(emptyTable.props.emptyMessage).toBe("Nenhum dado disponível.");
+  });
   it("uses supplied pre-pagination totals for daily footer metrics", () => {
     const table = CostGroupsTable({
       rows: [{ ...unavailableGroup, total_tokens: 5, estimated_brl: 2, estimated_usd: 1 }],
@@ -622,121 +727,6 @@ describe("grouped cost availability", () => {
     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: "",
-      provider: "",
-      phase: "",
-      origin: "",
-      workType: "",
-      agent: "",
-      model: "",
-      status: "",
-      priority: "",
-      risk: "",
-    };
-    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: "month",
-        snapshotBacked: true,
-      }),
-    ).toBe(true);
-  });
-  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",
-    });
-    // 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({
-      currency: "BRL",
-      fetcher: async (url) => {
-        calls.push(String(url));
-        return new Response(JSON.stringify({ runs: [] }), { status: 200 });
-      },
-    });
-    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",
-      to: "2026-07-26",
-    });
-    expect(costPeriodDateRange("7", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
-      from: "2026-07-20",
-      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();
-    const projection = { runs: [] };
-    const loaded = await loadCostMonitorPeriod({
-      currency: "BRL",
-      from: "2026-07-01",
-      to: "2026-07-26",
-      filters: {
-        query: "TASK-1",
-        provider: "openai",
-        phase: "execution",
-        origin: "spec",
-        workType: "rework",
-        agent: "zaip-agent-builder",
-        model: "gpt-5.6-terra",
-        status: "completed",
-        priority: "high",
-        risk: "standard",
-      },
-      signal: controller.signal,
-      fetcher: async (url, init) => {
-        calls.push({ url: String(url), signal: init?.signal });
-        return new Response(JSON.stringify(projection), {
-          headers: { "content-type": "application/json" },
-          status: 200,
-        });
-      },
-    });
-    expect(loaded).toEqual(projection);
-    expect(calls).toEqual([
-      {
-        url:
-          "/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({

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

@@ -6,6 +6,7 @@ import {
 } from "@zaip-ai/dashboard-ui";
 import type { CostGroupRow, CostRunRow, DurationCoverage } from "../contracts.js";
 import { MoreVerticalIcon } from "./CostTableIcons.js";
+import { type CostRunPagination, CostRunServerPagination } from "./CostTableLoading.js";
 import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
 import {
   agentRunModelPresentation,
@@ -30,6 +31,10 @@ import {
 } from "./cost-table-presentation.js";
 import type { CostGroupTotals } from "./use-cost-group-page.js";
 
+export {
+  type CostDeveloperAttributionRow,
+  CostDeveloperAttributionTable,
+} from "./CostDeveloperAttributionTable.js";
 export { CostModelsAuditTable } from "./CostModelsAuditTable.js";
 
 export {
@@ -269,16 +274,7 @@ export function CostRunsTable({
   currency: CostCurrency;
   locale: CostLocale;
   compact?: boolean;
-  pagination?: {
-    offset: number;
-    limit: number;
-    total: number | null;
-    has_more: boolean;
-    loading: boolean;
-    error: string | null;
-    onChange: (offset: number) => void;
-    onRetry: () => void;
-  };
+  pagination?: CostRunPagination;
 }) {
   const footerLabel = costRunsFooterLabel(locale, pagination !== undefined);
   const total = (key: keyof CostRunRow) => sumNumbers(rows.map((row) => row[key]));
@@ -599,63 +595,6 @@ function inclusiveTokenTotal(
     : row.total_tokens;
 }
 
-function CostRunServerPagination({
-  locale,
-  pagination,
-}: {
-  locale: CostLocale;
-  pagination: NonNullable<Parameters<typeof CostRunsTable>[0]["pagination"]>;
-}) {
-  const first = pagination.total === 0 ? 0 : pagination.offset + 1;
-  const last =
-    pagination.total === null
-      ? pagination.offset + pagination.limit
-      : Math.min(pagination.offset + pagination.limit, pagination.total);
-  const previous = Math.max(0, pagination.offset - pagination.limit);
-  const next = pagination.offset + pagination.limit;
-  return (
-    <nav
-      aria-label={locale === "pt-BR" ? "Paginação das invocações" : "Invocation pagination"}
-      className="ui-table-pagination"
-    >
-      <button
-        disabled={pagination.loading || pagination.offset === 0}
-        onClick={() => pagination.onChange(previous)}
-        type="button"
-      >
-        {locale === "pt-BR" ? "Anterior" : "Previous"}
-      </button>
-      <span aria-live="polite">
-        {pagination.loading
-          ? locale === "pt-BR"
-            ? "Carregando invocações…"
-            : "Loading invocations…"
-          : pagination.total === null
-            ? `${first}–${last}${pagination.has_more ? "+" : ""}`
-            : `${first}–${last} ${locale === "pt-BR" ? "de" : "of"} ${pagination.total}`}
-      </span>
-      <button
-        disabled={
-          pagination.loading ||
-          (!pagination.has_more && (pagination.total === null || next >= pagination.total))
-        }
-        onClick={() => pagination.onChange(next)}
-        type="button"
-      >
-        {locale === "pt-BR" ? "Próxima" : "Next"}
-      </button>
-      {pagination.error ? (
-        <span role="status">
-          {pagination.error}{" "}
-          <button onClick={pagination.onRetry} type="button">
-            {locale === "pt-BR" ? "Tentar novamente" : "Retry"}
-          </button>
-        </span>
-      ) : null}
-    </nav>
-  );
-}
-
 function costPeriodHeading(period: "daily" | "monthly" | "annual", locale: CostLocale): string {
   if (locale === "en-US") {
     return period === "daily" ? "Day" : period === "monthly" ? "Month" : "Year";
@@ -675,6 +614,7 @@ export function CostGroupsTable({
   dateHeading,
   labelHeading,
   totals: suppliedTotals,
+  loading = false,
 }: {
   rows: readonly CostGroupRow[];
   currency: CostCurrency;
@@ -687,6 +627,7 @@ export function CostGroupsTable({
   dateHeading?: string;
   labelHeading?: string;
   totals?: CostGroupTotals;
+  loading?: boolean;
 }) {
   const pageTotals = {
     runs: rows.reduce((sum, row) => sum + row.run_count, 0),
@@ -926,6 +867,15 @@ export function CostGroupsTable({
             : { key: "label", direction: "desc" }
       }
       locale={locale}
+      emptyMessage={
+        loading
+          ? locale === "pt-BR"
+            ? "Carregando…"
+            : "Loading…"
+          : locale === "pt-BR"
+            ? "Nenhum dado disponível."
+            : "No data available."
+      }
       pageSize={100}
       rowKey={(row) => row.key}
       onRowClick={onOpenTrace === undefined ? undefined : (row) => onOpenTrace(row.key)}

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

@@ -37,6 +37,7 @@ export const costCopy = {
       daily: "Diário",
       monthly: "Mensal",
       annual: "Anual",
+      developers: "Desenvolvedores",
     },
   },
   "en-US": {
@@ -73,6 +74,7 @@ export const costCopy = {
       daily: "Daily",
       monthly: "Monthly",
       annual: "Annual",
+      developers: "Developers",
     },
   },
 } as const;

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

@@ -11,7 +11,8 @@ export type CostView =
   | "models"
   | "daily"
   | "monthly"
-  | "annual";
+  | "annual"
+  | "developers";
 
 export const DEFAULT_COST_VIEW: CostView = "daily";
 
@@ -19,6 +20,7 @@ export const COST_VIEW_ORDER: readonly CostView[] = [
   "daily",
   "monthly",
   "annual",
+  "developers",
   "overview",
   "executions",
   "agentCalls",

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-page-range.ts

@@ -0,0 +1,35 @@
+import { type CostPeriod, defaultCostPeriod } from "./CostFilters.js";
+
+export type CostPageDateRange = { from: string; to: string };
+
+/**
+ * Embedded pages use the host's all-time atomic snapshot until an explicit
+ * period, date range, or local Cost filter narrows the population.
+ */
+export function resolveCostGroupPageRange({
+  embedded,
+  globalDateRange,
+  hasLocalCostFilters,
+  period,
+  runPageRange,
+}: {
+  embedded: boolean;
+  globalDateRange: { start: string; end: string } | undefined;
+  hasLocalCostFilters: boolean;
+  period: CostPeriod;
+  runPageRange: CostPageDateRange | undefined;
+}): CostPageDateRange | undefined {
+  if (
+    embedded &&
+    globalDateRange === undefined &&
+    period === defaultCostPeriod &&
+    !hasLocalCostFilters
+  )
+    return undefined;
+  return runPageRange;
+}
+
+/** Compact lifecycle tables share the same embedded snapshot contract. */
+export function resolveCompactCostPageRange(args: Parameters<typeof resolveCostGroupPageRange>[0]) {
+  return resolveCostGroupPageRange(args);
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-compact-cost-page.ts

@@ -28,15 +28,26 @@ export function compactReadModelKind(view: CostView): CompactReadModelKind | nul
     : null;
 }
 
+/** A page fallback is valid only for the same compact table surface. */
+export function isSameCompactCostSurface(resolvedKey: string | null, requestKey: string): boolean {
+  if (resolvedKey === null) return false;
+  return (
+    resolvedKey.slice(0, resolvedKey.lastIndexOf("\u0000")) ===
+    requestKey.slice(0, requestKey.lastIndexOf("\u0000"))
+  );
+}
+
 export function useCompactCostPage({
   view,
   load,
+  limit = 50,
   range,
   query,
   filters,
 }: {
   view: CostView;
   load: LoadCompactCostPage | undefined;
+  limit?: number;
   range: { from: string; to: string } | undefined;
   query: string | undefined;
   filters: CostFilterState;
@@ -54,10 +65,10 @@ export function useCompactCostPage({
   const rangeFrom = range?.from;
   const rangeTo = range?.to;
   const filterKey = Object.values(filters).join("\u0000");
-  const paginationKey = `${view}\u0000${query ?? ""}\u0000${rangeFrom ?? ""}\u0000${rangeTo ?? ""}\u0000${filterKey}`;
+  const paginationKey = `${view}\u0000${limit}\u0000${query ?? ""}\u0000${rangeFrom ?? ""}\u0000${rangeTo ?? ""}\u0000${filterKey}`;
   const requestKey = `${paginationKey}\u0000${offset}`;
-  const requestInputRef = useRef({ filters, query, rangeFrom, rangeTo });
-  requestInputRef.current = { filters, query, rangeFrom, rangeTo };
+  const requestInputRef = useRef({ filters, limit, query, rangeFrom, rangeTo });
+  requestInputRef.current = { filters, limit, query, rangeFrom, rangeTo };
   useEffect(() => {
     void paginationKey;
     setOffset(0);
@@ -81,7 +92,7 @@ export function useCompactCostPage({
     void loadPage({
       kind,
       offset,
-      limit: 50,
+      limit: requestInput.limit,
       ...(requestInput.rangeFrom === undefined || requestInput.rangeTo === undefined
         ? {}
         : { from: requestInput.rangeFrom, to: requestInput.rangeTo }),
@@ -112,6 +123,7 @@ export function useCompactCostPage({
     // A response for another tab, range, filter, or offset must never occupy
     // this view while the next request is in flight.
     compactPage: resolvedKey === requestKey ? page : null,
+    staleCompactPage: isSameCompactCostSurface(resolvedKey, requestKey) ? page : null,
     compactPageLoading: loading,
     compactPageError: error,
     retryCompactPage: () => setAttempt((value) => value + 1),

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-cost-group-page.test.ts

@@ -1,7 +1,9 @@
+import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import { isCurrentCostGroupPage } from "./use-cost-group-page.js";
+import { isSameCompactCostSurface } from "./use-compact-cost-page.js";
+import { isCurrentCostGroupPage, isSameCostGroupSurface } from "./use-cost-group-page.js";
 
-describe("Cost group page request identity", () => {
+describe("useCostGroupPage loading lifecycle", () => {
   it("masks a resolved monthly page while the annual request is pending", () => {
     const monthly = "monthly\u0000\u0000\u0000\u0000\u00000";
     const annual = "annual\u0000\u0000\u0000\u0000\u00000";
@@ -9,4 +11,37 @@ describe("Cost group page request identity", () => {
     expect(isCurrentCostGroupPage(monthly, annual)).toBe(false);
     expect(isCurrentCostGroupPage(annual, annual)).toBe(true);
   });
+
+  it("never reuses rows from another tab while its slow request is pending", () => {
+    const daily = "daily\u000010\u00002026-08-01\u00002026-08-25\u0000\u00000";
+    const models = "models\u000010\u00002026-08-01\u00002026-08-25\u0000\u00000";
+    const executions = "executions\u000010\u0000\u00002026-08-01\u00002026-08-25\u0000\u00000";
+    const tasks = "tasks\u000010\u0000\u00002026-08-01\u00002026-08-25\u0000\u00000";
+
+    expect(isSameCostGroupSurface(daily, models)).toBe(false);
+    expect(isSameCompactCostSurface(executions, tasks)).toBe(false);
+  });
+
+  it("keeps previous rows only while the next page of the same tab is pending", () => {
+    const firstPage = "daily\u000010\u00002026-08-01\u00002026-08-25\u0000\u00000";
+    const secondPage = "daily\u000010\u00002026-08-01\u00002026-08-25\u0000\u000010";
+
+    expect(isSameCostGroupSurface(firstPage, secondPage)).toBe(true);
+  });
+
+  it("invalidates an aborted request before clearing an inactive group view", () => {
+    const source = readFileSync(new URL("./use-cost-group-page.ts", import.meta.url), "utf8");
+
+    expect(source).toContain("const current = ++generation.current;");
+    expect(source).toContain("if (!active || !loader.current)");
+    expect(source).toContain("setLoading(false);");
+  });
+
+  it("handles loader failures instead of leaving a rejected promise", () => {
+    const source = readFileSync(new URL("./use-cost-group-page.ts", import.meta.url), "utf8");
+
+    expect(source).toContain(".catch((cause: unknown) => {");
+    expect(source).toContain("setError(cause instanceof Error ? cause.message : String(cause));");
+    expect(source).toContain("retry: () => setAttempt");
+  });
 });