@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/tests/e2e/specs/dashboard-performance-matrix.spec.ts

@@ -0,0 +1,743 @@
+import { expect, type Locator, type Page, test } from "@playwright/test";
+
+type Metric = {
+  surface: string;
+  period: "this-month" | "all";
+  ttfv_ms: number;
+  settled_ms: number;
+  request_count: number;
+};
+
+type SqlitePage = {
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  rows: readonly Record<string, unknown>[];
+};
+
+type PeriodQuery = { from: string | null; to: string | null };
+
+const costViews = [
+  ["Diário", "daily", "cost_monitor_daily"],
+  ["Mensal", "monthly", "cost_monitor_monthly"],
+  ["Anual", "annual", "cost_monitor_annual"],
+  ["Visão geral", "overview", null],
+  ["Execuções", "executions", "cost_monitor_executions"],
+  ["Invocações de Agentes", "agentCalls", "cost_monitor_agent_invocations"],
+  ["Zaip Agentes", "agents", "cost_monitor_zaip_agents"],
+  ["Modelos LLM", "models", "cost_monitor_models"],
+  ["Provedores", "providers", "cost_monitor_providers"],
+  ["Tarefas", "tasks", "cost_monitor_tasks"],
+  ["SPEC", "specs", "cost_monitor_specs"],
+  ["PRD", "prds", "cost_monitor_prds"],
+  ["Conversas", "conversations", "cost_monitor_conversations"],
+] as const;
+
+const workKinds = ["Tudo", "Tarefas", "Tarefa Avulsa", "PRDs", "SPECs"] as const;
+const boardStages = [
+  "definition",
+  "planning",
+  "ready",
+  "executing",
+  "verifying",
+  "completed",
+  "blocked",
+  "cancelled",
+  "failed",
+] as const;
+const workKindQuery = {
+  Tudo: null,
+  Tarefas: "task",
+  "Tarefa Avulsa": "standalone-task",
+  PRDs: "prd",
+  SPECs: "spec",
+} as const;
+
+type WorkKindLabel = (typeof workKinds)[number];
+type ApiUrlMatcher = (url: string) => boolean;
+
+test("measures Cost, Operation and Traceability surfaces without full snapshot hydration", async ({
+  page,
+}) => {
+  test.setTimeout(600_000);
+  const metrics: Metric[] = [];
+  const apiFailures: string[] = [];
+  const idleSnapshots: string[] = [];
+  const pageErrors: string[] = [];
+  const successfulApiResponses: string[] = [];
+  const requestStartedAt = new WeakMap<import("@playwright/test").Request, number>();
+  let apiRequestCount = 0;
+  const activeApiRequests = new Map<string, number>();
+  const apiActivityAt = new Map<string, number>();
+  page.on("request", (request) => {
+    if (!request.url().includes("/api/v2/")) return;
+    if (isBackgroundReconciliation(request.url())) return;
+    apiActivityAt.set(request.url(), performance.now());
+    requestStartedAt.set(request, performance.now());
+    apiRequestCount += 1;
+    activeApiRequests.set(request.url(), (activeApiRequests.get(request.url()) ?? 0) + 1);
+    if (new URL(request.url()).pathname === "/api/v2/snapshot") idleSnapshots.push(request.url());
+  });
+  const finishApiRequest = (request: { url(): string }) => {
+    if (!request.url().includes("/api/v2/")) return;
+    if (isBackgroundReconciliation(request.url())) return;
+    apiActivityAt.set(request.url(), performance.now());
+    const count = activeApiRequests.get(request.url()) ?? 0;
+    if (count <= 1) activeApiRequests.delete(request.url());
+    else activeApiRequests.set(request.url(), count - 1);
+  };
+  page.on("requestfinished", finishApiRequest);
+  page.on("requestfailed", finishApiRequest);
+  page.on("response", (response) => {
+    if (process.env.ZAIP_E2E_LOG_TIMINGS === "1") {
+      const startedAt = requestStartedAt.get(response.request());
+      if (startedAt !== undefined) {
+        console.log(
+          `DASHBOARD_API_TIMING ${Math.round(performance.now() - startedAt)}ms ${response.status()} ${response.url()}`,
+        );
+      }
+    }
+    if (
+      response.url().includes("/api/v2/") &&
+      !isBackgroundReconciliation(response.url()) &&
+      response.status() >= 400
+    ) {
+      apiFailures.push(`${response.status()} ${response.url()}`);
+    }
+    if (
+      response.url().includes("/api/v2/") &&
+      !isBackgroundReconciliation(response.url()) &&
+      response.status() < 400
+    ) {
+      successfulApiResponses.push(response.url());
+    }
+  });
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+
+  await installExportSink(page);
+  await openDashboard(page);
+  for (const period of ["this-month", "all"] as const) {
+    await selectPeriod(page, period);
+    const waitForApiQuiet = (matches: ApiUrlMatcher = () => true) =>
+      waitForQuietApiRequests(
+        () => [...activeApiRequests.keys()].filter(matches),
+        () => latestMatchingActivity(apiActivityAt, matches),
+      );
+    const responses = () => successfulApiResponses;
+    await exerciseCostMonitor(
+      page,
+      period,
+      metrics,
+      () => apiRequestCount,
+      waitForApiQuiet,
+      responses,
+    );
+    await exerciseOperations(
+      page,
+      period,
+      metrics,
+      () => apiRequestCount,
+      waitForApiQuiet,
+      responses,
+    );
+    await exerciseTraceability(
+      page,
+      period,
+      metrics,
+      () => apiRequestCount,
+      waitForApiQuiet,
+      responses,
+    );
+  }
+
+  await verifyCompleteCostExport(page);
+  await verifyCompleteWorkListExport(page);
+
+  expect(pageErrors).toEqual([]);
+  expect(apiFailures).toEqual([]);
+  expect(idleSnapshots).toEqual([]);
+  console.log(`DASHBOARD_PERFORMANCE_MATRIX ${JSON.stringify(metrics)}`);
+});
+
+async function openDashboard(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;
+  await expect(page.getByRole("navigation", { name: "Áreas do dashboard" })).toBeVisible();
+  await assertNoFullscreenOverlay(page);
+}
+
+async function selectPeriod(page: Page, period: "this-month" | "all") {
+  const control = page
+    .locator(".dashboard-global-controls")
+    .getByRole("combobox", { name: "Período" });
+  if ((await control.inputValue()) !== period) {
+    await control.selectOption(period);
+    await expect(control).toHaveValue(period);
+  }
+  await assertNoFullscreenOverlay(page);
+}
+
+async function exerciseCostMonitor(
+  page: Page,
+  period: Metric["period"],
+  metrics: Metric[],
+  requestCount: () => number,
+  waitForApiQuiet: (matches?: ApiUrlMatcher) => Promise<void>,
+  successfulResponses: () => readonly string[],
+) {
+  const navigation = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  const tabs = page.locator(".cost-tabs");
+  const expectedPeriod = await selectedPeriodQuery(page, period);
+
+  let enteringCostMonitor = true;
+  for (const [tab, content, apiView] of costViews) {
+    const button = tabs.getByRole("button", { exact: true, name: tab });
+    const costSurface = page.locator(`.cost-content-${content}`);
+    const costPageResponse =
+      apiView === null ? undefined : costPageResponseMatcher(apiView, expectedPeriod);
+    await measureSurface(
+      page,
+      metrics,
+      `cost:${tab}`,
+      period,
+      requestCount,
+      async () => {
+        if (enteringCostMonitor) {
+          enteringCostMonitor = false;
+          await navigation.getByRole("button", { name: /Monitor de Custos/ }).click();
+          await expect(tabs).toBeVisible({ timeout: 10_000 });
+          await assertNoFullscreenOverlay(page);
+        }
+        await button.click();
+        await expect(button).toHaveAttribute("aria-pressed", "true");
+        await expect(costSurface).toBeVisible();
+        await expect(
+          costSurface
+            .locator(".ui-table tbody tr, .ui-empty, .cost-period-average-card, .cost-chart")
+            .first(),
+        ).toBeVisible({ timeout: 10_000 });
+      },
+      async () => {
+        await expect(costSurface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+        await waitForApiQuiet();
+        await assertCostPagination(page, costSurface, costPageResponse);
+      },
+      successfulResponses,
+      costPageResponse === undefined ? undefined : [costPageResponse],
+    );
+  }
+}
+
+async function exerciseOperations(
+  page: Page,
+  period: Metric["period"],
+  metrics: Metric[],
+  requestCount: () => number,
+  waitForApiQuiet: (matches?: ApiUrlMatcher) => Promise<void>,
+  successfulResponses: () => readonly string[],
+) {
+  const navigation = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  const tabs = page.getByRole("navigation", { name: "Entidades do ciclo de trabalho" });
+  const expectedPeriod = await selectedPeriodQuery(page, period);
+  let enteringOperations = true;
+
+  for (const [viewLabel, content] of [
+    ["Visão de Quadro (Kanban)", ".operations-work-board"],
+    ["Visão de Lista", ".operations-work-list"],
+  ] as const) {
+    const view = tabs.getByRole("button", { exact: true, name: viewLabel });
+    for (const kind of workKinds) {
+      const surface = page.locator(content);
+      const selectionResponse = operationSelectionResponseMatcher(content, kind, expectedPeriod);
+      await measureSurface(
+        page,
+        metrics,
+        `operations:${viewLabel}:${kind}`,
+        period,
+        requestCount,
+        async () => {
+          if (enteringOperations) {
+            enteringOperations = false;
+            await navigation.getByRole("button", { name: /Operação/ }).click();
+            await expect(tabs).toBeVisible({ timeout: 10_000 });
+          }
+          await view.click();
+          await expect(view).toHaveAttribute("aria-pressed", "true");
+          const kindButton = page
+            .getByRole("navigation", { name: "Filtrar tipo de trabalho" })
+            .getByRole("button", { exact: true, name: kind });
+          await kindButton.click();
+          await expect(surface).toBeVisible();
+          await expect(
+            surface
+              .locator(".operations-work-card, .ui-table tbody tr, .ui-empty, .operations-empty")
+              .first(),
+          ).toBeVisible({ timeout: 10_000 });
+        },
+        async () => {
+          if (content === ".operations-work-list") {
+            await expect(surface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+            await assertWorkListPagination(page, surface, selectionResponse, waitForApiQuiet);
+          }
+          await waitForApiQuiet(selectionResponse);
+        },
+        successfulResponses,
+        content === ".operations-work-board"
+          ? boardStages.map((stage) =>
+              operationSelectionResponseMatcher(content, kind, expectedPeriod, stage),
+            )
+          : [selectionResponse],
+      );
+    }
+  }
+}
+
+async function exerciseTraceability(
+  page: Page,
+  period: Metric["period"],
+  metrics: Metric[],
+  requestCount: () => number,
+  waitForApiQuiet: (matches?: ApiUrlMatcher) => Promise<void>,
+  successfulResponses: () => readonly string[],
+) {
+  const navigation = page.getByRole("navigation", { name: "Áreas do dashboard" });
+  let selectedTaskId = "";
+  await measureSurface(
+    page,
+    metrics,
+    "traceability",
+    period,
+    requestCount,
+    async () => {
+      await navigation.getByRole("button", { name: /Rastreabilidade/ }).click();
+      const selector = page.getByRole("combobox", { name: "Buscar task por nome ou ID" });
+      await expect(selector).toBeVisible();
+      await selector.click();
+      const listbox = page.getByRole("listbox", { name: "Buscar task por nome ou ID" });
+      await expect(listbox).toBeVisible();
+      const task = listbox.getByRole("option").first();
+      await expect(task).toBeVisible();
+      selectedTaskId = traceTaskIdFromOption(await task.getAttribute("id"));
+      await task.click();
+      await expect(page.locator('section[aria-label="Rastreabilidade da task"]')).toBeVisible({
+        timeout: 10_000,
+      });
+    },
+    waitForApiQuiet,
+    successfulResponses,
+    [
+      (url) =>
+        new URL(url).pathname === `/api/v2/tasks/${encodeURIComponent(selectedTaskId)}/trace`,
+    ],
+  );
+}
+
+async function assertWorkListPagination(
+  page: Page,
+  surface: Locator,
+  matchesSelection: ApiUrlMatcher,
+  waitForApiQuiet: (matches?: ApiUrlMatcher) => Promise<void>,
+) {
+  const rows = surface.locator("table.ui-table tbody tr");
+  expect(await rows.count()).toBeLessThanOrEqual(10);
+  const pager = surface.getByRole("navigation", { name: "Paginação da lista de trabalho" });
+  await expect(pager).toBeVisible();
+  const totalText = await pager.locator("output").textContent();
+  const total = Number(totalText?.match(/de\s+(\d+)/)?.[1] ?? 0);
+  if (total > 10) {
+    const firstPageRows = await rowSignatures(rows);
+    const next = pager.getByRole("button", { name: "Próxima" });
+    await expect(next).toBeEnabled();
+    await assertNoFullscreenOverlay(page);
+    const nextResponse = waitForWorkListPageResponse(page, matchesSelection, 10);
+    await next.click();
+    await nextResponse;
+    await expect(pager.locator("output")).toContainText("11–", { timeout: 10_000 });
+    await expect(rows).toHaveCount(Math.min(10, total - 10), { timeout: 10_000 });
+    await expect(surface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+    expect(await rowSignatures(rows)).not.toEqual(firstPageRows);
+    // Filter hydration must not reset an already loaded page after navigation.
+    await waitForApiQuiet(matchesSelection);
+    await expect(pager.locator("output")).toContainText("11–", { timeout: 10_000 });
+    await expect(pager.getByRole("button", { name: "Anterior" })).toBeEnabled();
+    await assertNoFullscreenOverlay(page);
+    const firstPageResponse = waitForWorkListPageResponse(page, matchesSelection, 0);
+    await pager.getByRole("button", { name: "Anterior" }).click();
+    await firstPageResponse;
+    await expect(pager.locator("output")).toContainText("1–", { timeout: 10_000 });
+    await expect(rows).toHaveCount(Math.min(10, total), { timeout: 10_000 });
+    await expect(surface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+    expect(await rowSignatures(rows)).toEqual(firstPageRows);
+    await assertNoFullscreenOverlay(page);
+  }
+}
+
+function waitForWorkListPageResponse(page: Page, matchesSelection: ApiUrlMatcher, offset: number) {
+  return page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      matchesSelection(response.url()) &&
+      new URL(response.url()).searchParams.get("offset") === String(offset),
+    { timeout: 10_000 },
+  );
+}
+
+async function measureSurface(
+  page: Page,
+  metrics: Metric[],
+  surface: string,
+  period: Metric["period"],
+  requestCount: () => number,
+  action: () => Promise<void>,
+  settle: () => Promise<void>,
+  successfulResponses: () => readonly string[],
+  expectedApiResponses?: readonly ApiUrlMatcher[],
+) {
+  const startedAt = Date.now();
+  const requestsBefore = requestCount();
+  const responsesBefore = successfulResponses().length;
+  await action();
+  const ttfv = Date.now() - startedAt;
+  expect(ttfv, `${surface} first visual feedback`).toBeLessThan(10_000);
+  if (expectedApiResponses !== undefined) {
+    await expect
+      .poll(
+        () =>
+          expectedApiResponses.every((matches) =>
+            successfulResponses()
+              .slice(responsesBefore)
+              .some((url) => matches(url)),
+          ),
+        { timeout: 10_000, message: `${surface} responses for the selected surface` },
+      )
+      .toBe(true);
+  }
+  await settle();
+  await assertNoFullscreenOverlay(page);
+  const settled = Date.now() - startedAt;
+  expect(settled, `${surface} settled`).toBeLessThan(10_000);
+  metrics.push({
+    surface,
+    period,
+    ttfv_ms: ttfv,
+    settled_ms: settled,
+    request_count: requestCount() - requestsBefore,
+  });
+  if (process.env.ZAIP_E2E_LOG_TIMINGS === "1") {
+    console.log(`DASHBOARD_SURFACE_TIMING ${surface} ${period} ${ttfv}ms ${settled}ms`);
+  }
+}
+
+function operationSelectionResponseMatcher(
+  content: ".operations-work-board" | ".operations-work-list",
+  kind: WorkKindLabel,
+  period: PeriodQuery,
+  stage?: (typeof boardStages)[number],
+): ApiUrlMatcher {
+  return (url) => {
+    const parsed = new URL(url);
+    if (!matchesPeriodQuery(parsed, period) || !matchesWorkKindQuery(parsed, kind)) return false;
+    if (content === ".operations-work-list") {
+      return (
+        parsed.pathname === "/api/v2/sqlite-views" &&
+        parsed.searchParams.get("view") === "operations_work_list"
+      );
+    }
+    return (
+      parsed.pathname === "/api/v2/operations" &&
+      parsed.searchParams.get("scope") === "board" &&
+      (stage === undefined || parsed.searchParams.get("stage") === stage)
+    );
+  };
+}
+
+function costPageResponseMatcher(view: string, period: PeriodQuery): ApiUrlMatcher {
+  return (url) => {
+    const parsed = new URL(url);
+    return (
+      parsed.pathname === "/api/v2/sqlite-views" &&
+      parsed.searchParams.get("view") === view &&
+      matchesPeriodQuery(parsed, period)
+    );
+  };
+}
+
+function matchesWorkKindQuery(url: URL, kind: WorkKindLabel): boolean {
+  const expected = workKindQuery[kind];
+  return expected === null
+    ? !url.searchParams.has("kind")
+    : url.searchParams.get("kind") === expected;
+}
+
+function latestMatchingActivity(
+  activityAt: ReadonlyMap<string, number>,
+  matches: ApiUrlMatcher,
+): number | null {
+  let latest: number | null = null;
+  for (const [url, timestamp] of activityAt) {
+    if (matches(url) && (latest === null || timestamp > latest)) latest = timestamp;
+  }
+  return latest;
+}
+
+async function waitForQuietApiRequests(
+  getActiveApiRequests: () => readonly string[],
+  getLatestActivityAt: () => number | null,
+) {
+  await expect
+    .poll(
+      () => {
+        const latestActivityAt = getLatestActivityAt();
+        return (
+          getActiveApiRequests().length === 0 &&
+          latestActivityAt !== null &&
+          performance.now() - latestActivityAt >= 500
+        );
+      },
+      { timeout: 10_000 },
+    )
+    .toBe(true);
+}
+
+async function selectedPeriodQuery(page: Page, period: Metric["period"]): Promise<PeriodQuery> {
+  if (period === "all") return { from: null, to: null };
+  const controls = page.locator(".dashboard-global-controls");
+  return {
+    from: await controls.getByLabel("Data inicial").inputValue(),
+    to: await controls.getByLabel("Data final").inputValue(),
+  };
+}
+
+function matchesPeriodQuery(url: URL, period: PeriodQuery): boolean {
+  const from = url.searchParams.get("from");
+  const to = url.searchParams.get("to");
+  return from === period.from && to === period.to;
+}
+
+function traceTaskIdFromOption(optionId: string | null): string {
+  const prefix = "traceability-task-option-";
+  if (optionId === null || !optionId.startsWith(prefix)) {
+    throw new Error("Traceability option did not expose its task ID.");
+  }
+  return optionId.slice(prefix.length);
+}
+
+/** Startup reconciliation is intentionally non-blocking and is asserted separately. */
+function isBackgroundReconciliation(url: string): boolean {
+  return new URL(url).pathname === "/api/v2/reconcile-open-work";
+}
+
+async function assertCostPagination(
+  page: Page,
+  surface: Locator,
+  matchesPageResponse: ApiUrlMatcher | undefined,
+) {
+  for (const body of await surface.locator("table.ui-table tbody").all()) {
+    expect(await body.locator("tr").count()).toBeLessThanOrEqual(10);
+  }
+  const pager = surface
+    .getByRole("navigation", {
+      name: /Paginação (?:de grupos|das invocações|dos dados agregados)/,
+    })
+    .first();
+  if ((await pager.count()) === 0) return;
+  await expect(pager).toBeVisible();
+  const range = pager.locator("output, [aria-live='polite']").first();
+  const totalText = await range.textContent();
+  const total = Number(totalText?.match(/de\s+(\d+)/)?.[1] ?? 0);
+  const rows = surface.locator("table.ui-table tbody tr");
+  if (total <= 10) return;
+  const firstPageRows = await rowSignatures(rows);
+  const next = pager.getByRole("button", { name: "Próxima" });
+  await expect(next).toBeEnabled();
+  const nextResponse =
+    matchesPageResponse === undefined
+      ? undefined
+      : waitForCostPageResponse(page, matchesPageResponse, 10);
+  await next.click();
+  await nextResponse;
+  await expect(range).toContainText("11–", { timeout: 10_000 });
+  await expect(surface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+  expect(await rows.count()).toBeLessThanOrEqual(10);
+  expect(await rowSignatures(rows)).not.toEqual(firstPageRows);
+  await assertNoFullscreenOverlay(page);
+  const firstPageResponse =
+    matchesPageResponse === undefined
+      ? undefined
+      : waitForCostPageResponse(page, matchesPageResponse, 0);
+  await pager.getByRole("button", { name: "Anterior" }).click();
+  await firstPageResponse;
+  await expect(range).toContainText("1–", { timeout: 10_000 });
+  await expect(surface).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+  expect(await rowSignatures(rows)).toEqual(firstPageRows);
+  await assertNoFullscreenOverlay(page);
+}
+
+function waitForCostPageResponse(page: Page, matchesPageResponse: ApiUrlMatcher, offset: number) {
+  return page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      matchesPageResponse(response.url()) &&
+      new URL(response.url()).searchParams.get("offset") === String(offset),
+    { timeout: 10_000 },
+  );
+}
+
+async function rowSignatures(rows: Locator): Promise<string[]> {
+  return rows.evaluateAll((entries) =>
+    entries.map((entry) => (entry.textContent ?? "").replace(/\s+/g, " ").trim()),
+  );
+}
+
+async function assertNoFullscreenOverlay(page: Page) {
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: 10_000 });
+}
+
+async function verifyCompleteCostExport(page: Page) {
+  await selectPeriod(page, "all");
+  await page
+    .getByRole("navigation", { name: "Áreas do dashboard" })
+    .getByRole("button", { name: /Monitor de Custos/ })
+    .click();
+  for (const item of [
+    { tab: "Diário", content: "daily", view: "cost_monitor_daily", limit: 50 },
+    { tab: "Execuções", content: "executions", view: "cost_monitor_executions", limit: 50 },
+    {
+      tab: "Invocações de Agentes",
+      content: "agentCalls",
+      view: "cost_monitor_agent_invocations",
+      limit: 100,
+    },
+  ] as const) {
+    await page.locator(".cost-tabs").getByRole("button", { exact: true, name: item.tab }).click();
+    const content = page.locator(`.cost-content-${item.content}`);
+    await expect(content).not.toHaveAttribute("aria-busy", "true", { timeout: 10_000 });
+    expect(await content.locator("table.ui-table tbody tr").count()).toBeLessThanOrEqual(10);
+    const pages = await captureExportPages(page, item.view, item.limit, async () => {
+      await page.getByRole("button", { name: "Exportar Excel" }).click();
+    });
+    assertCompleteExport(pages);
+  }
+}
+
+async function verifyCompleteWorkListExport(page: Page) {
+  await page
+    .getByRole("navigation", { name: "Áreas do dashboard" })
+    .getByRole("button", { name: /Operação/ })
+    .click();
+  await page
+    .getByRole("navigation", { name: "Entidades do ciclo de trabalho" })
+    .getByRole("button", { exact: true, name: "Visão de Lista" })
+    .click();
+  const list = page.locator(".operations-work-list");
+  await expect(list).toBeVisible();
+  await expect(list.locator("table.ui-table tbody tr")).toHaveCount(10, { timeout: 10_000 });
+  const pages = await captureExportPages(page, "operations_work_list", 100, async () => {
+    await page.getByRole("button", { name: "Exportar Excel" }).click();
+  });
+  assertCompleteExport(pages);
+}
+
+async function captureExportPages(
+  page: Page,
+  view: string,
+  limit: number,
+  action: () => Promise<void>,
+): Promise<SqlitePage[]> {
+  const pages: SqlitePage[] = [];
+  const closedBefore = await exportCloseCount(page);
+  const onResponse = async (response: import("@playwright/test").Response) => {
+    const url = new URL(response.url());
+    if (response.status() !== 200 || url.pathname !== "/api/v2/sqlite-views") return;
+    if (url.searchParams.get("view") !== view || url.searchParams.get("limit") !== String(limit))
+      return;
+    pages.push((await response.json()) as SqlitePage);
+  };
+  page.on("response", onResponse);
+  try {
+    await action();
+    await expect.poll(() => pages.some((entry) => !entry.has_more), { timeout: 60_000 }).toBe(true);
+    await expect
+      .poll(() => exportCloseCount(page), { timeout: 60_000 })
+      .toBeGreaterThan(closedBefore);
+    return pages;
+  } finally {
+    page.off("response", onResponse);
+  }
+}
+
+function assertCompleteExport(pages: SqlitePage[]) {
+  expect(pages.length).toBeGreaterThan(0);
+  const [firstPage] = pages;
+  if (firstPage === undefined) throw new Error("Export did not return a page.");
+  const total = firstPage.total_count;
+  expect(pages.every((page) => page.total_count === total)).toBe(true);
+  let expectedOffset = 0;
+  const identities = new Set<string>();
+  for (const page of pages) {
+    expect(page.offset).toBe(expectedOffset);
+    expectedOffset += page.rows.length;
+    for (const row of page.rows) {
+      const identity = exportRowIdentity(row);
+      expect(identities.has(identity), `duplicate exported row ${identity}`).toBe(false);
+      identities.add(identity);
+    }
+  }
+  expect(pages.reduce((sum, page) => sum + page.rows.length, 0)).toBe(total);
+  expect(identities.size).toBe(total);
+  expect(pages.at(-1)?.has_more).toBe(false);
+}
+
+function exportRowIdentity(row: Record<string, unknown>): string {
+  for (const key of [
+    "agent_invocation_id",
+    "execution_id",
+    "conversation_id",
+    "task_id",
+    "spec_id",
+    "prd_id",
+    "period_key",
+    "key",
+    "id",
+  ]) {
+    const value = row[key];
+    if (typeof value === "string" && value.length > 0) return `${key}:${value}`;
+  }
+  return JSON.stringify(row);
+}
+
+async function exportCloseCount(page: Page): Promise<number> {
+  return page.evaluate(
+    () => (window as Window & { __zaipExportCloseCount?: number }).__zaipExportCloseCount ?? 0,
+  );
+}
+
+async function installExportSink(page: Page) {
+  await page.addInitScript(() => {
+    (window as Window & { __zaipExportCloseCount?: number }).__zaipExportCloseCount = 0;
+    Object.assign(window, {
+      showSaveFilePicker: async ({ suggestedName }: { suggestedName: string }) => {
+        const writer = {
+          abort: async () => undefined,
+          close: async () => {
+            const state = window as Window & { __zaipExportCloseCount?: number };
+            state.__zaipExportCloseCount = (state.__zaipExportCloseCount ?? 0) + 1;
+          },
+          ready: Promise.resolve(),
+          write: async () => undefined,
+        };
+        return {
+          name: suggestedName,
+          createWritable: async () => ({ ...writer, getWriter: () => writer }),
+        };
+      },
+    });
+  });
+}