@zaip-ai/cli 1.3.0 → 1.3.2

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard.test.mjs

@@ -1,6 +1,6 @@
 import { EventEmitter } from "node:events";
 import { mkdir, mkdtemp, readFile, rm, utimes } from "node:fs/promises";
-import { connect, createServer } from "node:net";
+import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
@@ -21,7 +21,6 @@ import {
   recordPortStatus,
   registeredListenerMatches,
   runtimeKind,
-  startDashboardLaunchPage,
   stopOwnedDashboardProcess,
   stripTerminalControlCodes,
   teardownWarning,
@@ -95,7 +94,7 @@ describe("dashboard executable session", () => {
 
   it("opens preparation before checking freshness and keeps it through server health", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-    const lock = source.indexOf("await withLauncherLock(async () => {");
+    const lock = source.indexOf("await withLauncherLock(");
     const preparation = source.indexOf("launchPage = await startDashboardLaunchPage(0);");
     const freshness = source.indexOf("const buildSignature = await ensureFreshDashboardBuild();");
     const server = source.indexOf(
@@ -118,6 +117,7 @@ describe("dashboard executable session", () => {
     );
     expect(wait).toContain("Dashboard data readiness returned ${readiness.status}");
     expect(wait).toContain("unavailable.retryable = false;");
+    expect(wait).toContain("timedOut.retryable = false;");
     expect(wait).toContain("if (error?.retryable === false) throw error;");
     expect(wait).toContain("await delay(100);");
   });
@@ -135,27 +135,49 @@ describe("dashboard executable session", () => {
 
   it("uses one durable cache and an append-only worker log for a stale snapshot refresh", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
-
+    const refresh = await readFile(
+      new URL("./start-dashboard-refresh.mjs", import.meta.url),
+      "utf8",
+    );
     expect(source).toContain(
       'const sqliteSnapshotCacheDirectory = join(sqliteReadModelDirectory, "cache");',
     );
-    expect(source).toContain("ZAIP_SQLITE_CACHE_DIR: sqliteSnapshotCacheDirectory,");
+    expect(refresh).toContain("ZAIP_WORKSPACE: workspaceRoot,");
+    expect(refresh).toContain("ZAIP_SQLITE_CACHE_DIR: cacheDirectory,");
     expect(source).toContain(
       'const refreshLogPath = join(sessionDirectory, "dashboard-sqlite-refresh.log");',
     );
-    expect(source).toContain('stdio: ["ignore", refreshLogDescriptor, refreshLogDescriptor]');
-    expect(source).toContain("worker log ${refreshLogPath}");
+    expect(refresh).toContain('stdio: ["ignore", descriptor, descriptor]');
+    expect(refresh).toContain("worker log ${refreshLogPath}");
   });
 
-  it("keeps a visible, actionable handoff watchdog instead of closing the preparation page before navigation", async () => {
-    const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
+  it("persists the refresh worker PID before another launcher click may coalesce it", async () => {
+    const refresh = await readFile(
+      new URL("./start-dashboard-refresh.mjs", import.meta.url),
+      "utf8",
+    );
 
-    expect(source).toContain('id="handoff-link"');
+    expect(refresh).toContain("await acquireRefreshLock(lockPath, isProcessAlive)");
+    expect(refresh).toContain("if (await isRunning())");
+    expect(refresh).toContain("await writeJsonAtomic(refreshStatusPath, {");
+    expect(refresh).toContain("await stopProcessTree(worker.pid).catch(() => {});");
+    const runningBarrier = refresh.slice(0, refresh.indexOf('worker.once("error"'));
+    expect(runningBarrier).not.toContain("void writeJsonAtomic(refreshStatusPath, {");
+  });
+
+  it("keeps the automatic handoff status visible instead of offering an unreliable local link", async () => {
+    const [source, launcherSource] = await Promise.all([
+      readFile(new URL("./start-dashboard-launch-page.mjs", import.meta.url), "utf8"),
+      readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8"),
+    ]);
+
+    expect(source).toContain("O dashboard está pronto. Abrindo a tela principal automaticamente…");
+    expect(source).not.toContain('id="handoff-link"');
     expect(source).toContain("function showHandoff(target)");
     expect(source).toContain("setTimeout(()=>location.replace(next.target),0)");
     expect(source).toContain("closeAfterHandoffGrace: (graceMs = 12_000)");
-    expect(source).toContain("launchPage.closeAfterHandoffGrace();");
-    expect(source).not.toContain("await launchPage.close();\n  if (!redirected");
+    expect(launcherSource).toContain("launchPage.closeAfterHandoffGrace();");
+    expect(launcherSource).not.toContain("await launchPage.close();\n  if (!redirected");
   });
 
   it("tears down prior owned sessions only after the new browser handoff", async () => {
@@ -279,13 +301,22 @@ describe("dashboard executable session", () => {
     ]);
   });
 
+  it("keeps a Linux browser fallback when xdg-open is unavailable", () => {
+    const target = "http://127.0.0.1:4317/?token=local-session-token";
+
+    expect(browserLaunchCommands(target, "linux")).toEqual([
+      ["xdg-open", [target]],
+      ["gio", ["open", target]],
+    ]);
+  });
+
   it("falls back to another browser command when the first option fails", async () => {
     let calls = 0;
     const spawnImpl = () => {
-      calls += 1;
+      const attempt = ++calls;
       const child = new EventEmitter();
       child.unref = () => {};
-      queueMicrotask(() => child.emit(calls === 1 ? "error" : "spawn", new Error("failed")));
+      queueMicrotask(() => child.emit(attempt === 1 ? "error" : "spawn", new Error("failed")));
       return child;
     };
 
@@ -293,58 +324,6 @@ describe("dashboard executable session", () => {
     expect(calls).toBe(2);
   });
 
-  it("serves a viewport-covering centered progress overlay while the runtime starts", async () => {
-    const launchPage = await startDashboardLaunchPage(0);
-    try {
-      const page = await fetch(`http://${host}:${launchPage.port}/?token=temporary`);
-      const health = await fetch(`http://${host}:${launchPage.port}/api/v2/health`);
-
-      expect(page.status).toBe(200);
-      const html = await page.text();
-      expect(html).toContain('class="launch-overlay"');
-      expect(html).toContain("position:fixed;inset:0;width:100vw;height:100vh");
-      expect(html).toContain("display:grid;place-items:center");
-      expect(html).toContain('aria-live="polite" role="status"');
-      expect(html).toContain("abra o dashboard agora");
-      expect(html).toContain("function showHandoff(target)");
-      const progress = await fetch(`http://${host}:${launchPage.port}/api/v2/progress`);
-      await expect(progress.json()).resolves.toMatchObject({
-        phase: "Iniciando o launcher local",
-        percent: expect.any(Number),
-      });
-      expect(health.status).toBe(503);
-      await expect(health.json()).resolves.toEqual({
-        kind: "zaip-dashboard-launcher",
-        status: "starting",
-      });
-
-      launchPage.redirect("http://127.0.0.1:4317/?token=reused-session");
-      const ready = await fetch(`http://${host}:${launchPage.port}/api/v2/ready`);
-      await expect(ready.json()).resolves.toEqual({
-        target: "http://127.0.0.1:4317/?token=reused-session",
-      });
-      await expect(launchPage.waitForRedirect(10)).resolves.toBe(true);
-    } finally {
-      await launchPage.close();
-    }
-  });
-
-  it("bounds launch-page shutdown when a browser connection never finishes polling", async () => {
-    const launchPage = await startDashboardLaunchPage(0);
-    const connection = connect({ host, port: launchPage.port });
-    await new Promise((resolveConnected, rejectConnected) => {
-      connection.once("connect", resolveConnected);
-      connection.once("error", rejectConnected);
-    });
-    const closed = new Promise((resolveClosed) => connection.once("close", resolveClosed));
-    const startedAt = Date.now();
-    await launchPage.close({ forceAfterMs: 20 });
-    await closed;
-
-    expect(Date.now() - startedAt).toBeLessThan(500);
-    expect(connection.destroyed).toBe(true);
-  });
-
   it("reuses a healthy session owned by the same workspace", async () => {
     const directory = await temporaryDirectory();
     const path = join(directory, "dashboard-session.json");
@@ -630,7 +609,7 @@ describe("dashboard executable session", () => {
   it("opens preparation before waiting and only reuses after checking the current build", async () => {
     const source = await readFile(new URL("./start-dashboard.mjs", import.meta.url), "utf8");
     const preparation = source.indexOf("launchPage = await startDashboardLaunchPage(0);");
-    const lock = source.indexOf("await withLauncherLock(async () => {");
+    const lock = source.indexOf("await withLauncherLock(");
     const buildSignature = source.indexOf(
       "const buildSignature = await ensureFreshDashboardBuild();",
     );
@@ -645,7 +624,8 @@ describe("dashboard executable session", () => {
     expect(source).toContain(
       'snapshotState: snapshotCache === "stale_seed" ? "updating" : "current",',
     );
-    expect(source).toContain("if (launchPage !== null) await launchPage.close().catch(() => {});");
+    expect(source).toContain("launchPage.setFailure({");
+    expect(source).toContain("launchPage.closeAfterFailureObservation();");
     expect(source).toContain('await writeLauncherStatus("ok");');
   });
 
@@ -666,8 +646,9 @@ describe("dashboard executable session", () => {
       "utf8",
     );
 
-    expect(source).toContain("DateTime.UtcNow.AddSeconds(135)");
-    expect(source).toContain("mais de 135 segundos");
+    expect(source).toContain("DateTime.UtcNow.AddSeconds(420)");
+    expect(source).toContain("lock window (210 s)");
+    expect(source).toContain("bounded 180 s server");
   });
 });
 

package/templates/.agents/dashboard/packages/windows-launcher/Program.cs

@@ -82,7 +82,10 @@ namespace ZaipDashboardLauncher
             // The Node launcher coalesces concurrent clicks and may wait for a
             // healthy build/handoff.  Keep this wrapper alive for that bounded
             // handoff instead of showing a second failure dialog.
-            var deadline = DateTime.UtcNow.AddSeconds(135);
+            // A waiting click can spend the Node lock window (210 s) behind
+            // the current leader, then still needs the bounded 180 s server
+            // startup window if that leader fails before publishing a session.
+            var deadline = DateTime.UtcNow.AddSeconds(420);
             while (DateTime.UtcNow < deadline)
             {
                 try
@@ -122,7 +125,7 @@ namespace ZaipDashboardLauncher
                 }
                 Thread.Sleep(100);
             }
-            return ReportFailure("O dashboard demorou mais de 135 segundos para abrir. As tentativas foram interrompidas; tente novamente.");
+            return ReportFailure("O dashboard ainda não publicou uma sessão pronta após 420 segundos. O processo local pode continuar registrando detalhes no log temporário; feche esta mensagem e tente novamente após verificar o log.");
         }
 
         private static bool VerifyDashboardLaunch(string workspaceRoot, out string error)

package/templates/.agents/dashboard/tests/e2e/playwright.config.ts

@@ -22,12 +22,15 @@ export default defineConfig({
     cwd: workspaceRoot,
     url: `${baseURL}/api/v2/health`,
     reuseExistingServer: false,
-    timeout: 30_000,
+    timeout: 120_000,
     env: {
       ZAIP_UI_TOKEN: "e2e-token",
       ZAIP_SERVER_PORT: serverPort,
       ZAIP_WORKSPACE: workspaceRoot,
       ZAIP_UI_ROOT: resolve(workspaceRoot, ".agents/dashboard/apps/frontend/dist"),
+      // Match the Windows launcher: first paint uses the latest validated
+      // immutable seed while canonical refresh work stays off the served path.
+      ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "1",
     },
   },
 });

package/templates/.agents/dashboard/tests/e2e/specs/cost-monitor-loading.spec.ts

@@ -0,0 +1,142 @@
+import { expect, test } from "@playwright/test";
+
+declare global {
+  interface Window {
+    __costAbortRaceProbe: {
+      abortObserved: boolean;
+      overlayPresentAtSwitch: boolean | null;
+      shellInertAtSwitch: boolean | null;
+      switched: boolean;
+    };
+  }
+}
+
+test("releases an aborted Cost group load and keeps Operation reachable", async ({ page }) => {
+  await page.addInitScript(() => {
+    const probe = {
+      abortObserved: false,
+      overlayPresentAtSwitch: null as boolean | null,
+      shellInertAtSwitch: null as boolean | null,
+      switched: false,
+    };
+    const originalFetch = window.fetch.bind(window);
+    Object.assign(window, { __costAbortRaceProbe: probe });
+    window.fetch = (input, init) => {
+      const requestUrl = new URL(
+        typeof input === "string" ? input : input instanceof URL ? input.href : input.url,
+        window.location.href,
+      );
+      if (
+        !probe.switched &&
+        requestUrl.pathname === "/api/v2/sqlite-views" &&
+        requestUrl.searchParams.get("view") === "cost_monitor_daily"
+      ) {
+        const executionsTab = Array.from(
+          document.querySelectorAll<HTMLButtonElement>(".cost-tabs button"),
+        ).find((button) => button.textContent?.trim() === "Execuções");
+        if (executionsTab !== undefined) {
+          probe.overlayPresentAtSwitch =
+            document.querySelector(".period-transition-overlay") !== null;
+          probe.shellInertAtSwitch = executionsTab.closest("[inert]") !== null;
+          init?.signal?.addEventListener("abort", () => {
+            probe.abortObserved = true;
+          });
+          probe.switched = true;
+          executionsTab.click();
+        }
+      }
+      return originalFetch(input, init);
+    };
+  });
+
+  await openDashboard(page);
+  await expectGlobalMonthPreset(page);
+  const capabilityNav = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  await capabilityNav.getByRole("button", { name: /Monitor de Custos/ }).click();
+  const costTabs = page.locator(".cost-tabs");
+  await expect(costTabs).toBeVisible();
+  await expect
+    .poll(() => page.evaluate(() => window.__costAbortRaceProbe))
+    .toMatchObject({
+      abortObserved: true,
+      overlayPresentAtSwitch: false,
+      shellInertAtSwitch: false,
+      switched: true,
+    });
+
+  const executionsTab = costTabs.getByRole("button", { exact: true, name: "Execuções" });
+  await expect(executionsTab).toHaveAttribute("aria-pressed", "true");
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 15_000 });
+
+  await capabilityNav.getByRole("button", { name: /Operação/ }).click();
+  await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0);
+});
+
+test("loads every Cost Monitor tab before returning to Operation", async ({ page }) => {
+  const pageErrors: string[] = [];
+  const failedApiResponses: string[] = [];
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+  page.on("response", (response) => {
+    if (
+      response.url().includes("/api/v2/") &&
+      !response.url().includes("/api/v2/reconcile-open-work") &&
+      response.status() >= 400
+    )
+      failedApiResponses.push(`${response.status()} ${response.url()}`);
+  });
+
+  await openDashboard(page);
+  await expectGlobalMonthPreset(page);
+  const capabilityNav = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  await capabilityNav.getByRole("button", { name: /Monitor de Custos/ }).click();
+  const costTabs = page.locator(".cost-tabs");
+  await expect(costTabs).toBeVisible();
+
+  for (const [tab, view] of [
+    ["Diário", "daily"],
+    ["Mensal", "monthly"],
+    ["Anual", "annual"],
+    ["Visão geral", "overview"],
+    ["Execuções", "executions"],
+    ["Invocações de Agentes", "agentCalls"],
+    ["Zaip Agentes", "agents"],
+    ["Modelos LLM", "models"],
+    ["Provedores", "providers"],
+    ["Tarefas", "tasks"],
+    ["SPEC", "specs"],
+    ["PRD", "prds"],
+    ["Conversas", "conversations"],
+  ] as const) {
+    await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 30_000 });
+    const button = costTabs.getByRole("button", { exact: true, name: tab });
+    await button.click();
+    await expect(button).toHaveAttribute("aria-pressed", "true");
+    await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 30_000 });
+    await expect(page.locator(`.cost-content-${view}`)).toBeVisible();
+    await expect(page.locator(".cost-period-error")).toHaveCount(0);
+  }
+
+  await capabilityNav.getByRole("button", { name: /Operação/ }).click();
+  await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0);
+  expect(pageErrors).toEqual([]);
+  expect(failedApiResponses).toEqual([]);
+});
+
+async function expectGlobalMonthPreset(page: import("@playwright/test").Page) {
+  await expect(
+    page.locator(".dashboard-global-controls").getByRole("combobox", { name: "Período" }),
+  ).toHaveValue("this-month");
+}
+
+async function openDashboard(page: import("@playwright/test").Page) {
+  const operations = page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      response.url().includes("/api/v2/operations") &&
+      response.url().includes("scope=quick"),
+  );
+  await page.goto("/?token=e2e-token");
+  return operations;
+}

package/templates/.agents/dashboard/tests/e2e/specs/cost-monitor-pagination.spec.ts

@@ -0,0 +1,232 @@
+import { expect, type Page, type Response, test } from "@playwright/test";
+
+declare global {
+  interface Window {
+    __paginationExportProbe: { closes: number; writes: number };
+  }
+}
+
+type TargetView = {
+  tab: string | RegExp;
+  content: string;
+  sqliteView: string;
+  pagerName: string;
+  exportLimit: number;
+};
+
+type SqlitePage = {
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  rows: readonly Record<string, unknown>[];
+};
+
+const targets: readonly TargetView[] = [
+  {
+    tab: "Execuções",
+    content: "executions",
+    sqliteView: "cost_monitor_executions",
+    pagerName: "Paginação dos dados agregados",
+    exportLimit: 50,
+  },
+  {
+    tab: "Invocações de Agentes",
+    content: "agentCalls",
+    sqliteView: "cost_monitor_agent_invocations",
+    pagerName: "Paginação das invocações",
+    exportLimit: 100,
+  },
+  {
+    tab: /Zaip (?:Agentes|Agents)/,
+    content: "agents",
+    sqliteView: "cost_monitor_zaip_agents",
+    pagerName: "Paginação de grupos",
+    exportLimit: 50,
+  },
+  {
+    tab: "Tarefas",
+    content: "tasks",
+    sqliteView: "cost_monitor_tasks",
+    pagerName: "Paginação dos dados agregados",
+    exportLimit: 50,
+  },
+  {
+    tab: "Conversas",
+    content: "conversations",
+    sqliteView: "cost_monitor_conversations",
+    pagerName: "Paginação dos dados agregados",
+    exportLimit: 50,
+  },
+];
+
+test("serves ten rows and exercises Next/Previous on every reported slow tab", async ({ page }) => {
+  const tabs = await openAllTimeCostMonitor(page);
+  const measurements: Array<{ tab: string; first_ms: number; next_ms: number }> = [];
+
+  for (const target of targets) {
+    const button = tabs.getByRole("button", { exact: true, name: target.tab });
+    const first = await requestPage(page, target.sqliteView, 0, 10, () => button.click());
+    const content = page.locator(`.cost-content-${target.content}`);
+    await expect(button).toHaveAttribute("aria-pressed", "true");
+    await expect(content).toBeVisible();
+    await expect(content.locator("table.ui-table tbody tr")).toHaveCount(10);
+    expect(first.payload).toMatchObject({ offset: 0, limit: 10, has_more: true });
+    expect(first.payload.total_count).toBeGreaterThan(10);
+    expect(first.elapsedMs).toBeLessThan(5_000);
+
+    let pager = content.getByRole("navigation", { name: target.pagerName });
+    await expect(pager).toContainText(`1–10 de ${first.payload.total_count}`);
+    await expect(pager.getByRole("button", { name: "Anterior" })).toBeDisabled();
+    await expect(pager.getByRole("button", { name: "Próxima" })).toBeEnabled();
+
+    const next = await requestPage(page, target.sqliteView, 10, 10, () =>
+      pager.getByRole("button", { name: "Próxima" }).click(),
+    );
+    pager = content.getByRole("navigation", { name: target.pagerName });
+    await expect(content.locator("table.ui-table tbody tr")).toHaveCount(10);
+    await expect(pager).toContainText(`11–20 de ${first.payload.total_count}`);
+    await expect(pager.getByRole("button", { name: "Anterior" })).toBeEnabled();
+    expect(next.elapsedMs).toBeLessThan(5_000);
+
+    await requestPage(page, target.sqliteView, 0, 10, () =>
+      pager.getByRole("button", { name: "Anterior" }).click(),
+    );
+    await expect(content.getByRole("navigation", { name: target.pagerName })).toContainText(
+      `1–10 de ${first.payload.total_count}`,
+    );
+    measurements.push({
+      tab: typeof target.tab === "string" ? target.tab : "Zaip Agents",
+      first_ms: first.elapsedMs,
+      next_ms: next.elapsedMs,
+    });
+  }
+
+  console.log(`COST_PAGINATION_TIMINGS ${JSON.stringify(measurements)}`);
+});
+
+for (const target of targets) {
+  const label = typeof target.tab === "string" ? target.tab : "Zaip Agents";
+  test(`exports the complete ${label} population independently from its ten-row visual page`, async ({
+    page,
+  }) => {
+    test.setTimeout(360_000);
+    await installExportSink(page);
+    const tabs = await openAllTimeCostMonitor(page);
+    const pages: SqlitePage[] = [];
+    page.on("response", async (response) => {
+      if (!isSqliteResponse(response, target.sqliteView)) return;
+      try {
+        const payload = (await response.json()) as SqlitePage;
+        if (payload.limit === target.exportLimit) pages.push(payload);
+      } catch {
+        // A failed/non-JSON response is asserted by the missing complete page below.
+      }
+    });
+    const button = tabs.getByRole("button", { exact: true, name: target.tab });
+    await requestPage(page, target.sqliteView, 0, 10, () => button.click());
+    await page.getByRole("button", { name: "Exportar Excel" }).click();
+    await expect
+      .poll(() => page.evaluate(() => window.__paginationExportProbe.closes), { timeout: 300_000 })
+      .toBe(1);
+    await expect(page.getByText("Exportação concluída.", { exact: true })).toBeVisible({
+      timeout: 30_000,
+    });
+    await expect.poll(() => pages.some((entry) => !entry.has_more), { timeout: 30_000 }).toBe(true);
+
+    expect(pages.length).toBeGreaterThan(0);
+    expect(pages.every((entry) => entry.limit === target.exportLimit)).toBe(true);
+    expect(pages.map((entry) => entry.offset)).toEqual(
+      pages.map((_, index) => index * target.exportLimit),
+    );
+    const total = pages[0]!.total_count;
+    expect(pages.every((entry) => entry.total_count === total)).toBe(true);
+    expect(pages.reduce((sum, entry) => sum + entry.rows.length, 0)).toBe(total);
+    expect(pages.at(-1)?.has_more).toBe(false);
+    console.log(`COST_EXPORT_TOTAL ${label} ${total}`);
+  });
+}
+
+async function openAllTimeCostMonitor(page: Page) {
+  const operations = page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      response.url().includes("/api/v2/operations") &&
+      response.url().includes("scope=quick"),
+  );
+  await page.goto("/?token=e2e-token");
+  await operations;
+  const period = page
+    .locator(".dashboard-global-controls")
+    .getByRole("combobox", { name: "Período" });
+  if ((await period.inputValue()) !== "all") {
+    await period.selectOption("all");
+    await expect(period).toHaveValue("all");
+  }
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 60_000 });
+  await page
+    .getByRole("navigation", { name: "Áreas do dashboard" })
+    .getByRole("button", { name: /Monitor de Custos/ })
+    .click();
+  const tabs = page.locator(".cost-tabs");
+  await expect(tabs).toBeVisible();
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 60_000 });
+  return tabs;
+}
+
+async function requestPage(
+  page: Page,
+  view: string,
+  offset: number,
+  limit: number,
+  action: () => Promise<unknown>,
+) {
+  const startedAt = Date.now();
+  const responsePromise = page.waitForResponse(
+    (response) =>
+      isSqliteResponse(response, view) &&
+      new URL(response.url()).searchParams.get("offset") === String(offset) &&
+      new URL(response.url()).searchParams.get("limit") === String(limit),
+  );
+  await action();
+  const response = await responsePromise;
+  const elapsedMs = Date.now() - startedAt;
+  expect(response.status()).toBe(200);
+  const payload = (await response.json()) as SqlitePage;
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 60_000 });
+  return { payload, elapsedMs };
+}
+
+function isSqliteResponse(response: Response, view: string): boolean {
+  const url = new URL(response.url());
+  return (
+    response.status() === 200 &&
+    url.pathname === "/api/v2/sqlite-views" &&
+    url.searchParams.get("view") === view
+  );
+}
+
+async function installExportSink(page: Page) {
+  await page.addInitScript(() => {
+    const probe = { closes: 0, writes: 0 };
+    Object.assign(window, { __paginationExportProbe: probe });
+    Object.assign(window, {
+      showSaveFilePicker: async ({ suggestedName }: { suggestedName: string }) => {
+        const writer = {
+          abort: async () => undefined,
+          close: async () => {
+            probe.closes += 1;
+          },
+          ready: Promise.resolve(),
+          write: async () => {
+            probe.writes += 1;
+          },
+        };
+        return {
+          name: suggestedName,
+          createWritable: async () => ({ ...writer, getWriter: () => writer }),
+        };
+      },
+    });
+  });
+}