@zaip-ai/cli 1.0.6 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/execution-metrics.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import {
+  analyticalDuration,
+  effortMetricTotals,
+  executionMetricRuns,
+  executionMetricTotals,
+} from "./execution-metrics.js";
+
+describe("analyticalDuration", () => {
+  it("accepts only an observed source duration", () => {
+    expect(
+      analyticalDuration({
+        id: "OBSERVED",
+        duration_ms: 60_000,
+        source_duration_ms: 1_000,
+        usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+      }),
+    ).toBe(1_000);
+    expect(
+      analyticalDuration({
+        id: "OBSERVED-ZERO",
+        duration_ms: 60_000,
+        source_duration_ms: 0,
+        usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+      }),
+    ).toBe(0);
+    expect(
+      analyticalDuration({
+        id: "RECONCILED",
+        duration_ms: 60_000,
+        source_duration_ms: null,
+        duration_provenance: "reconciled",
+        usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+      }),
+    ).toBeNull();
+    expect(
+      analyticalDuration({
+        id: "ESTIMATED",
+        duration_ms: 60_000,
+        source_duration_ms: null,
+        usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+      }),
+    ).toBeNull();
+  });
+
+  it("uses only deduplicated root execution Runs with source duration", () => {
+    const usage = { total: { tokens: { total: null }, cost: { brl: null } } };
+    const runs = [
+      {
+        id: "ROOT-OBSERVED",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: 3_600_000,
+        duration_ms: 3_600_000,
+        usage,
+      },
+      {
+        id: "ROOT-RECONCILED",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: null,
+        duration_ms: 1_800_000,
+        duration_provenance: "reconciled" as const,
+        usage,
+      },
+      {
+        id: "ROOT-LEGACY",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: null,
+        duration_ms: 900_000,
+        duration_provenance: "legacy_inferred" as const,
+        usage,
+      },
+      {
+        id: "CHILD",
+        phase: "execution",
+        parent_run_id: "ROOT-OBSERVED",
+        source_duration_ms: 7_200_000,
+        duration_ms: 7_200_000,
+        usage,
+      },
+      {
+        id: "ROOT-ESTIMATED",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: null,
+        duration_ms: 230.1 * 3_600_000,
+        duration_provenance: "estimated" as const,
+        usage,
+      },
+      {
+        id: "ROOT-UNAVAILABLE",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: null,
+        duration_ms: 230.1 * 3_600_000,
+        duration_provenance: "unavailable" as const,
+        usage,
+      },
+      {
+        id: "ROOT-OBSERVED",
+        phase: "execution",
+        parent_run_id: null,
+        source_duration_ms: 9_999_999,
+        duration_ms: 9_999_999,
+        usage,
+      },
+    ];
+
+    expect(executionMetricRuns(runs).map((run) => run.id)).toEqual([
+      "ROOT-OBSERVED",
+      "ROOT-RECONCILED",
+      "ROOT-LEGACY",
+      "ROOT-ESTIMATED",
+      "ROOT-UNAVAILABLE",
+    ]);
+    expect(executionMetricTotals(runs).durationMs).toBe(3_600_000);
+  });
+
+  it("measures all deduplicated invocation effort without lifecycle elapsed", () => {
+    const run = (
+      id: string,
+      phase: "conversation" | "planning" | "execution",
+      duration_ms: number | null,
+      source_duration_ms: number | null,
+      duration_provenance:
+        | "reconciled"
+        | "legacy_inferred"
+        | "estimated"
+        | "unavailable"
+        | undefined,
+      tokens: number,
+      cost: number,
+      parent_run_id: string | null = null,
+    ) => ({
+      id,
+      phase,
+      parent_run_id,
+      duration_ms,
+      source_duration_ms,
+      duration_provenance,
+      // 230.1h lifecycle elapsed is deliberately not a metric input.
+      started_at: "2026-08-01T00:00:00.000Z",
+      finished_at: "2026-08-10T14:06:00.000Z",
+      usage: { total: { tokens: { total: tokens }, cost: { brl: cost } } },
+    });
+    const runs = [
+      run("ROOT-SIMPLE", "conversation", 600_000, 600_000, undefined, 10, 1),
+      run("ROOT-DELEGATED", "planning", 1_200_000, null, "reconciled", 20, 2),
+      run("CHILD", "execution", 1_800_000, null, "legacy_inferred", 30, 3, "ROOT-DELEGATED"),
+      run("ESTIMATED", "execution", 828_360_000, null, "estimated", 40, 4),
+      run("UNAVAILABLE", "conversation", 828_360_000, null, "unavailable", 50, 5),
+      run("CHILD", "execution", 9_999_999, 9_999_999, undefined, 99, 99, "ROOT-DELEGATED"),
+    ];
+
+    expect(effortMetricTotals(runs)).toMatchObject({
+      durationMs: 600_000,
+      tokens: 150,
+      costBrl: 15,
+    });
+    expect(effortMetricTotals(runs).runs.map((entry) => entry.id)).toEqual([
+      "ROOT-SIMPLE",
+      "ROOT-DELEGATED",
+      "CHILD",
+      "ESTIMATED",
+      "UNAVAILABLE",
+    ]);
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/react/execution-metrics.ts

@@ -0,0 +1,88 @@
+import { globalLegacyEffortDurationMs } from "../contracts.js";
+
+/** Shared, deduplicated population for Operations metric consumers. */
+export interface ExecutionMetricRun {
+  id: string;
+  phase?: string;
+  parent_run_id?: string | null;
+  started_at?: string;
+  finished_at?: string | null;
+  source_duration_ms?: number | null;
+  duration_provenance?:
+    | "observed"
+    | "reconciled"
+    | "legacy_inferred"
+    | "estimated"
+    | "unavailable"
+    | undefined;
+  duration_ms: number | null;
+  usage: { total: { tokens: { total: number | null }; cost: { brl: number | null } } };
+}
+
+export function executionMetricRuns<T extends ExecutionMetricRun>(runs: readonly T[]): T[] {
+  const unique = new Map<string, T>();
+  for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  return [...unique.values()].filter(
+    (run) =>
+      (run.phase === undefined || run.phase === "execution") &&
+      (run.parent_run_id === null ||
+        run.parent_run_id === undefined ||
+        !unique.has(run.parent_run_id)),
+  );
+}
+
+export function metricRuns<T extends ExecutionMetricRun>(runs: readonly T[]): T[] {
+  const unique = new Map<string, T>();
+  for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  return [...unique.values()];
+}
+
+export function observedDuration(value: number | null): number | null {
+  return value !== null && value >= 0 ? value : null;
+}
+
+/** Only provider-observed source duration is analytical input. */
+export function analyticalDuration(run: ExecutionMetricRun): number | null {
+  return observedDuration(run.source_duration_ms ?? null);
+}
+
+export function sumObserved(values: readonly (number | null)[]): number | null {
+  const observed = values.filter((value): value is number => value !== null);
+  return observed.length === 0 ? null : observed.reduce((sum, value) => sum + value, 0);
+}
+
+export function executionMetricTotals<T extends ExecutionMetricRun>(runs: readonly T[]) {
+  const population = executionMetricRuns(runs);
+  return {
+    runs: population,
+    durationMs: sumObserved(population.map(analyticalDuration)),
+    tokens: sumObserved(population.map((run) => run.usage.total.tokens.total)),
+    costBrl: sumObserved(population.map((run) => run.usage.total.cost.brl)),
+  };
+}
+
+/** Canonical effort population: every deduplicated Run across all phases. */
+export function effortMetricTotals<T extends ExecutionMetricRun>(runs: readonly T[]) {
+  const population = metricRuns(runs);
+  return {
+    runs: population,
+    durationMs: sumObserved(population.map(analyticalDuration)),
+    tokens: sumObserved(population.map((run) => run.usage.total.tokens.total)),
+    costBrl: sumObserved(population.map((run) => run.usage.total.cost.brl)),
+  };
+}
+
+export function globalLegacyEffortMetricDuration<T extends ExecutionMetricRun>(runs: readonly T[]) {
+  return globalLegacyEffortDurationMs(runs, analyticalDuration);
+}
+
+/** Shared analytical total: every deduplicated observed execution Run, including Sub-Runs. */
+export function operationalRootExecutionDuration<T extends ExecutionMetricRun>(runs: readonly T[]) {
+  return executionMetricTotals(runs).durationMs;
+}
+
+/** Financial/usage cards span every filtered phase; duration remains execution-only. */
+export function allPhaseMetricTotals<T extends ExecutionMetricRun>(runs: readonly T[]) {
+  const totals = effortMetricTotals(runs);
+  return { runs: totals.runs, tokens: totals.tokens, costBrl: totals.costBrl };
+}

package/templates/.agents/dashboard/modules/operations/src/react/export/ExcelExportAction.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { EXPORT_SUCCESS_TOAST_MS, exportRowsWithDurationHours } from "./ExcelExportAction.js";
+
+describe("ExcelExportAction duration mapper", () => {
+  it("exports millisecond durations as unrounded numeric base hours with explicit hour headers", () => {
+    expect(
+      exportRowsWithDurationHours([
+        {
+          durationMs: 9_593_507,
+          duration_ms: 3_600_000,
+          source_duration_ms: 7_200_000,
+          averageRunDurationMs: null,
+        },
+      ]),
+    ).toEqual([
+      {
+        durationHours: 2.6648630555555557,
+        duration_hours: 1,
+        source_duration_hours: 2,
+        averageRunDurationHours: null,
+      },
+    ]);
+  });
+});
+
+it("keeps success feedback duration at four seconds", () => {
+  expect(EXPORT_SUCCESS_TOAST_MS).toBe(4_000);
+});
+
+it("clears pending success when a new export starts", () => {
+  expect("running").not.toBe("completed");
+});

package/templates/.agents/dashboard/modules/operations/src/react/export/ExcelExportAction.tsx

@@ -0,0 +1,93 @@
+import { createExportSnapshot } from "@zaip-ai/dashboard-contracts";
+import { Download } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { ExportProgressToast, ExportSuccessToast } from "./ExportProgressToast.js";
+import { ExportController, type ExportState } from "./export-session.js";
+
+export type ExcelExportInput = {
+  view: string;
+  filters: Readonly<Record<string, unknown>>;
+  rows: readonly Record<string, unknown>[];
+};
+export const EXPORT_SUCCESS_TOAST_MS = 4_000;
+
+export function exportRowsWithDurationHours(
+  rows: readonly Record<string, unknown>[],
+): Record<string, unknown>[] {
+  return rows.map((row) =>
+    Object.fromEntries(
+      Object.entries(row).map(([key, value]) => {
+        const durationKey = durationHoursKey(key);
+        if (durationKey === null)
+          return [key, value !== null && typeof value === "object" ? JSON.stringify(value) : value];
+        return [durationKey, typeof value === "number" ? value / 3_600_000 : value];
+      }),
+    ),
+  );
+}
+
+function durationHoursKey(key: string): string | null {
+  if (key === "durationMs") return "durationHours";
+  if (key.endsWith("DurationMs")) return `${key.slice(0, -2)}Hours`;
+  if (key === "duration_ms") return "duration_hours";
+  return key.endsWith("_duration_ms") ? `${key.slice(0, -2)}hours` : null;
+}
+
+export function ExcelExportAction({ filters, rows, view }: ExcelExportInput) {
+  const controller = useRef<ExportController | null>(null);
+  if (controller.current === null) controller.current = new ExportController();
+  const [state, setState] = useState<ExportState>(controller.current.state);
+  const [showSuccess, setShowSuccess] = useState(false);
+  useEffect(() => controller.current?.subscribe(setState), []);
+  useEffect(() => {
+    if (state.status !== "completed") {
+      setShowSuccess(false);
+      return;
+    }
+    setShowSuccess(true);
+    const timer = setTimeout(() => setShowSuccess(false), EXPORT_SUCCESS_TOAST_MS);
+    return () => clearTimeout(timer);
+  }, [state.status]);
+  const headers: string[] = [];
+  const headerSet = new Set<string>();
+  for (const row of rows)
+    for (const key of Object.keys(row)) {
+      const header = durationHoursKey(key) ?? key;
+      if (!headerSet.has(header)) {
+        headerSet.add(header);
+        headers.push(header);
+      }
+    }
+  if (headers.length === 0) headers.push("result");
+  const start = () => {
+    const snapshot = createExportSnapshot({
+      id: globalThis.crypto?.randomUUID?.() ?? `export-${Date.now()}`,
+      createdAt: new Date().toISOString(),
+      view,
+      filters,
+      totalRows: rows.length,
+      pages: async function* () {
+        for (let offset = 0; offset < rows.length; offset += 500)
+          yield exportRowsWithDurationHours(rows.slice(offset, offset + 500));
+      },
+    });
+    void controller.current?.start({ snapshot, headers, view }).catch(() => undefined);
+  };
+  return (
+    <>
+      <button
+        aria-label="Exportar Excel"
+        className="excel-export-action"
+        disabled={state.status === "running"}
+        onClick={start}
+        type="button"
+      >
+        <Download aria-hidden="true" size={16} />
+        Exportar Excel
+      </button>
+      {state.status === "running" ? <ExportProgressToast progress={state.progress} /> : null}
+      {showSuccess ? <ExportSuccessToast /> : null}
+      {state.status === "failed" ? <p role="alert">Falha ao exportar: {state.error}</p> : null}
+    </>
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/export/ExportProgressToast.tsx

@@ -0,0 +1,26 @@
+import "./export.css";
+
+export function ExportProgressToast({
+  progress,
+  keepOpen = true,
+}: {
+  progress: number;
+  keepOpen?: boolean;
+}) {
+  return (
+    <aside aria-live="polite" className="export-progress" role="status">
+      <strong>Exportação em andamento</strong>
+      <progress max={100} value={progress} aria-label="Progresso da exportação" />
+      {keepOpen && <span>Mantenha a página aberta.</span>}
+      <span>{Math.round(progress)}%</span>
+    </aside>
+  );
+}
+
+export function ExportSuccessToast() {
+  return (
+    <aside aria-live="polite" className="export-success" role="status">
+      Exportação concluída.
+    </aside>
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/export/export-layout.test.ts

@@ -0,0 +1,67 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const operationsPage = readFileSync(new URL("../OperationsPage.tsx", import.meta.url), "utf8");
+const costMonitorPage = readFileSync(
+  new URL("../../../../cost-monitor/src/react/CostMonitorPage.tsx", import.meta.url),
+  "utf8",
+);
+const action = readFileSync(new URL("./ExcelExportAction.tsx", import.meta.url), "utf8");
+const css = readFileSync(new URL("./export.css", import.meta.url), "utf8");
+const operationsCss = readFileSync(new URL("../operations.css", import.meta.url), "utf8");
+const costMonitorCss = readFileSync(
+  new URL("../../../../cost-monitor/src/react/cost-monitor.css", import.meta.url),
+  "utf8",
+);
+
+describe("Excel export layout", () => {
+  it("uses the Download icon and explicit Excel export label", () => {
+    expect(action).toContain('import { Download } from "lucide-react"');
+    expect(action).toContain('aria-label="Exportar Excel"');
+    expect(action).toContain("<Download");
+    expect(action).toContain("Exportar Excel");
+  });
+
+  it("places the Operations action inside the tab nav, not global controls", () => {
+    const controls = operationsPage.slice(
+      operationsPage.indexOf('<section className="dashboard-global-controls">'),
+      operationsPage.indexOf(
+        "</section>",
+        operationsPage.indexOf('<section className="dashboard-global-controls">'),
+      ),
+    );
+    const toolbar = operationsPage.slice(
+      operationsPage.indexOf('<section className="operations-toolbar">'),
+      operationsPage.indexOf(
+        "</section>",
+        operationsPage.indexOf('<section className="operations-toolbar">'),
+      ),
+    );
+    expect(controls).not.toContain("<ExcelExportAction");
+    expect(toolbar.indexOf(").map((key) =>")).toBeLessThan(toolbar.indexOf("<ExcelExportAction"));
+  });
+
+  it("places the Cost Monitor action inside cost-tabs and keeps tab-like action styling", () => {
+    const tabs = costMonitorPage.slice(
+      costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
+      costMonitorPage.indexOf(
+        "</nav>",
+        costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
+      ),
+    );
+    expect(tabs.indexOf("COST_VIEW_ORDER.map")).toBeLessThan(tabs.indexOf("<ExcelExportAction"));
+    expect(css).toContain(".excel-export-action");
+    expect(css).toContain("display: inline-flex");
+  });
+
+  it("keeps both tab bars compact, wrapped, and free of horizontal scrolling", () => {
+    for (const tabCss of [operationsCss, costMonitorCss]) {
+      expect(tabCss).toContain("flex-wrap: wrap");
+      expect(tabCss).toContain("overflow-x: visible");
+      expect(tabCss).toContain("gap: 6px");
+      expect(tabCss).toContain("min-height: 40px");
+      expect(tabCss).toContain("font-size: 0.82rem");
+      expect(tabCss).toMatch(/padding(?:-inline)?:[^;]*10px/);
+    }
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/react/export/export-session.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createExportSnapshot } from "../../../../../packages/data-export/src/index.js";
+import {
+  chooseExportDestination,
+  ExportController,
+  exportFileBaseName,
+  exportFileName,
+} from "./export-session.js";
+
+type FilePickerGlobal = typeof globalThis & {
+  showDirectoryPicker?: () => Promise<FileSystemDirectoryHandle>;
+  showSaveFilePicker?: () => Promise<FileSystemFileHandle>;
+};
+const pickerGlobal = globalThis as FilePickerGlobal;
+const originalPicker = pickerGlobal.showSaveFilePicker;
+const originalDirectoryPicker = pickerGlobal.showDirectoryPicker;
+
+function snapshot() {
+  return createExportSnapshot({
+    id: "small-v2",
+    createdAt: "2026-07-31T00:00:00.000Z",
+    view: "View",
+    filters: { status: "active" },
+    totalRows: 1,
+    pages: async function* () {
+      yield [{ id: 1 }];
+    },
+  });
+}
+
+function file(options: { failWrite?: boolean } = {}) {
+  const writes: Uint8Array[] = [];
+  let aborted = false;
+  return {
+    writes,
+    wasAborted: () => aborted,
+    handle: {
+      name: "view.xlsx",
+      async createWritable() {
+        return {
+          async write(value: ArrayBuffer) {
+            if (options.failWrite) throw new Error("disk full");
+            writes.push(new Uint8Array(value));
+          },
+          async close() {},
+          async abort() {
+            aborted = true;
+          },
+          getWriter() {
+            return {
+              ready: Promise.resolve(undefined),
+              write: this.write,
+              close: this.close,
+              abort: this.abort,
+            };
+          },
+        };
+      },
+    } as unknown as FileSystemFileHandle,
+  };
+}
+
+afterEach(() => {
+  Object.defineProperty(globalThis, "showSaveFilePicker", {
+    configurable: true,
+    value: originalPicker,
+  });
+  Object.defineProperty(globalThis, "showDirectoryPicker", {
+    configurable: true,
+    value: originalDirectoryPicker,
+  });
+});
+
+describe("export session", () => {
+  it("picks an XLSX file before writing", async () => {
+    const target = file();
+    let pickerOptions: unknown;
+    Object.defineProperty(globalThis, "showSaveFilePicker", {
+      configurable: true,
+      value: async (options: unknown) => {
+        pickerOptions = options;
+        return target.handle;
+      },
+    });
+    Object.defineProperty(globalThis, "showDirectoryPicker", {
+      configurable: true,
+      value: () => {
+        throw new Error("directory picker must not be called");
+      },
+    });
+    const controller = new ExportController();
+
+    await controller.start({ snapshot: snapshot(), headers: ["id"], view: "View" });
+
+    expect(pickerOptions).toMatchObject({
+      id: expect.stringMatching(/^[A-Za-z0-9_-]{1,32}$/),
+      startIn: "downloads",
+      suggestedName: expect.stringMatching(/^\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-view\.xlsx$/),
+      types: [
+        {
+          description: "Pasta de trabalho Excel",
+          accept: {
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": [".xlsx"],
+          },
+        },
+      ],
+    });
+    expect(target.writes[0]?.slice(0, 2)).toEqual(new Uint8Array([0x50, 0x4b]));
+    expect(controller.state).toMatchObject({
+      status: "completed",
+      progress: 100,
+      completedFiles: ["view.xlsx"],
+    });
+  });
+
+  it("locks export module-wide while another controller is awaiting Save As", async () => {
+    let resolvePicker!: (value: FileSystemFileHandle) => void;
+    const target = file();
+    Object.defineProperty(globalThis, "showSaveFilePicker", {
+      configurable: true,
+      value: () =>
+        new Promise<FileSystemFileHandle>((resolve) => {
+          resolvePicker = resolve;
+        }),
+    });
+    const first = new ExportController();
+    const second = new ExportController();
+    const pending = first.start({ snapshot: snapshot(), headers: ["id"], view: "View" });
+
+    await expect(
+      second.start({ snapshot: snapshot(), headers: ["id"], view: "View" }),
+    ).rejects.toThrow("already running");
+    resolvePicker(target.handle);
+    await pending;
+  });
+
+  it("keeps idle when the user cancels Save As", async () => {
+    Object.defineProperty(globalThis, "showSaveFilePicker", {
+      configurable: true,
+      value: async () => {
+        throw Object.assign(new Error("cancelled"), { name: "AbortError" });
+      },
+    });
+    const controller = new ExportController();
+
+    await expect(
+      controller.start({ snapshot: snapshot(), headers: ["id"], view: "View" }),
+    ).rejects.toMatchObject({
+      name: "AbortError",
+    });
+    expect(controller.state).toMatchObject({ status: "idle", error: null, message: null });
+  });
+
+  it("aborts the selected file when XLSX writing fails", async () => {
+    const target = file({ failWrite: true });
+    Object.defineProperty(globalThis, "showSaveFilePicker", {
+      configurable: true,
+      value: async () => target.handle,
+    });
+    const controller = new ExportController();
+
+    await expect(
+      controller.start({ snapshot: snapshot(), headers: ["id"], view: "View" }),
+    ).rejects.toThrow("disk full");
+    expect(target.wasAborted()).toBe(true);
+    expect(controller.state).toMatchObject({ status: "failed", message: null });
+  });
+
+  it("uses one ZIP Save As selection for multipart exports", async () => {
+    const target = file();
+    const options: unknown[] = [];
+    Object.defineProperty(globalThis, "showSaveFilePicker", {
+      configurable: true,
+      value: async (pickerOptions: unknown) => {
+        options.push(pickerOptions);
+        return target.handle;
+      },
+    });
+
+    await chooseExportDestination(true, "view");
+
+    expect(options).toEqual([
+      expect.objectContaining({
+        id: expect.stringMatching(/^[A-Za-z0-9_-]{1,32}$/),
+        startIn: "downloads",
+        suggestedName: "view.zip",
+        types: [{ description: "Arquivo ZIP", accept: { "application/zip": [".zip"] } }],
+      }),
+    ]);
+  });
+
+  it("uses the timestamped base for a single file and every multipart ZIP entry", () => {
+    const exportedAt = new Date("2026-08-02T01:01:00.000Z");
+
+    expect(exportFileBaseName("Operations Daily", exportedAt)).toBe(
+      "2026-08-01-22-01-operations-daily",
+    );
+    expect(`${exportFileBaseName("Operations Daily", exportedAt)}.xlsx`).toBe(
+      "2026-08-01-22-01-operations-daily.xlsx",
+    );
+    expect(exportFileName("Visão / Total", 1, exportedAt)).toBe(
+      "2026-08-01-22-01-visao-total-part-1.xlsx",
+    );
+    expect(exportFileName("Visão / Total", 2, exportedAt)).toBe(
+      "2026-08-01-22-01-visao-total-part-2.xlsx",
+    );
+  });
+});