@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -2,6 +2,10 @@ import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 
 const operationsPage = readFileSync(new URL("../OperationsPage.tsx", import.meta.url), "utf8");
+const operationsNavigation = readFileSync(
+  new URL("../OperationsPageNavigation.tsx", import.meta.url),
+  "utf8",
+);
 const costMonitorPage = readFileSync(
   new URL("../../../../cost-monitor/src/react/CostMonitorPage.tsx", import.meta.url),
   "utf8",
@@ -20,9 +24,28 @@ describe("Excel export layout", () => {
     expect(action).toContain('aria-label="Exportar Excel"');
     expect(action).toContain("<Download");
     expect(action).toContain("Exportar Excel");
+    expect(action).toContain("ExportProgressToast");
+  });
+
+  it("uses the paginated board source rather than just visible Kanban rows", () => {
+    expect(operationsPage).toContain(
+      'pageSource={\n                        view === "work-kanban"',
+    );
+    expect(operationsPage).toContain("boardExportSource?.({");
+  });
+
+  it("uses the paginated SQLite source for every Operations table, not the visible page", () => {
+    expect(operationsPage).toContain("detailExportSource?.(view, {");
+    const app = readFileSync(
+      new URL("../../../../../apps/frontend/src/App.tsx", import.meta.url),
+      "utf8",
+    );
+    expect(app).toContain('executions: "operations_executions"');
+    expect(app).toContain("totalRows: firstPage.total_count");
+    expect(app).toContain("if (nextOffset >= page.total_count) return");
   });
 
-  it("places the Operations action inside the tab nav, not global controls", () => {
+  it("keeps the Operations action outside the tab nav and fixed at the bar end", () => {
     const controls = operationsPage.slice(
       operationsPage.indexOf('<section className="dashboard-global-controls">'),
       operationsPage.indexOf(
@@ -38,10 +61,13 @@ describe("Excel export layout", () => {
       ),
     );
     expect(controls).not.toContain("<ExcelExportAction");
-    expect(toolbar.indexOf(").map((key) =>")).toBeLessThan(toolbar.indexOf("<ExcelExportAction"));
+    expect(toolbar).toContain("<OperationsViewTabs");
+    expect(operationsNavigation).toContain("views.map((key) =>");
+    expect(operationsNavigation).not.toContain("<ExcelExportAction");
+    expect(toolbar).toContain('<div className="operations-tab-export">');
   });
 
-  it("places the Cost Monitor action inside cost-tabs and keeps tab-like action styling", () => {
+  it("keeps Cost Monitor tabs semantic and fixes the export action at the bar end", () => {
     const tabs = costMonitorPage.slice(
       costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
       costMonitorPage.indexOf(
@@ -49,7 +75,10 @@ describe("Excel export layout", () => {
         costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
       ),
     );
-    expect(tabs.indexOf("COST_VIEW_ORDER.map")).toBeLessThan(tabs.indexOf("<ExcelExportAction"));
+    expect(tabs).toContain("COST_VIEW_ORDER.map");
+    expect(tabs).not.toContain("<ExcelExportAction");
+    expect(costMonitorPage).toContain('<div className="cost-tabs-bar">');
+    expect(costMonitorPage).toContain('<div className="cost-tab-export">');
     expect(css).toContain(".excel-export-action");
     expect(css).toContain("display: inline-flex");
   });
@@ -63,5 +92,14 @@ describe("Excel export layout", () => {
       expect(tabCss).toContain("font-size: 0.82rem");
       expect(tabCss).toMatch(/padding(?:-inline)?:[^;]*10px/);
     }
+    expect(costMonitorCss).toContain("grid-template-columns: minmax(0, 1fr) auto");
+    expect(costMonitorCss).toContain("min-height: 44px");
+    expect(costMonitorCss).toContain("border-radius: 999px");
+    expect(costMonitorCss).toContain("font-size: 0.82rem");
+    expect(costMonitorCss).toContain("width: 14px");
+    expect(costMonitorPage).not.toContain("cost-coverage-note");
+    expect(costMonitorCss).not.toContain("cost-coverage-note");
+    expect(operationsCss).toContain(".operations-tab-export .excel-export-action");
+    expect(operationsCss).toContain("width: 14px");
   });
 });

package/templates/.agents/dashboard/modules/operations/src/react/export/xlsx-runtime-e2e.test.ts

@@ -0,0 +1,248 @@
+import { readdirSync } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+// `exceljs` exposes this Node-specific entrypoint without a declaration file.
+// The runtime export test needs the Node loader rather than ExcelJS's browser build.
+// @ts-expect-error TS7016: upstream package omits declarations for `exceljs.nodejs.js`.
+import ExcelJS from "../../../../../packages/data-export/node_modules/exceljs/lib/exceljs.nodejs.js";
+import {
+  createExportSnapshot,
+  exportSnapshotToXlsxParts,
+} from "../../../../../packages/data-export/src/index.js";
+import {
+  AGENT_INVOCATION_EXPORT_COLUMNS,
+  CHANGE_EXPORT_COLUMNS,
+  COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+  CONVERSATION_EXPORT_COLUMNS,
+  COST_GROUP_EXPORT_COLUMNS,
+  DECISION_EXPORT_COLUMNS,
+  EXECUTION_EXPORT_COLUMNS,
+  exportAgentInvocationRows,
+  exportCompactLifecycleRows,
+  exportConversationRows,
+  exportCostGroupRows,
+  exportExecutionRows,
+  exportRowsWithDurationHours,
+  exportWorkRows,
+  PERIOD_EXPORT_COLUMNS,
+  WORK_EXPORT_COLUMNS,
+} from "./ExcelExportAction.js";
+
+type Row = Record<string, unknown>;
+type Mapper = (rows: readonly Row[]) => Row[];
+type Case = { name: string; view: string; headers: readonly string[]; map: Mapper };
+const enabled = process.env.ZAIP_E2E_XLSX_EXPORTS === "1";
+const cases: readonly Case[] = [
+  {
+    name: "cost-daily",
+    view: "cost_monitor_daily",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+  {
+    name: "cost-monthly",
+    view: "cost_monitor_monthly",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+  {
+    name: "cost-annual",
+    view: "cost_monitor_annual",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+  {
+    name: "cost-executions",
+    view: "cost_monitor_executions",
+    headers: COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+    map: exportCompactLifecycleRows,
+  },
+  {
+    name: "cost-agent-calls",
+    view: "cost_monitor_agent_invocations",
+    headers: AGENT_INVOCATION_EXPORT_COLUMNS,
+    map: exportAgentInvocationRows,
+  },
+  {
+    name: "cost-tasks",
+    view: "cost_monitor_tasks",
+    headers: COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+    map: exportCompactLifecycleRows,
+  },
+  {
+    name: "cost-specs",
+    view: "cost_monitor_specs",
+    headers: COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+    map: exportCompactLifecycleRows,
+  },
+  {
+    name: "cost-prds",
+    view: "cost_monitor_prds",
+    headers: COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+    map: exportCompactLifecycleRows,
+  },
+  {
+    name: "cost-conversations",
+    view: "cost_monitor_conversations",
+    headers: COMPACT_LIFECYCLE_EXPORT_COLUMNS,
+    map: exportCompactLifecycleRows,
+  },
+  {
+    name: "cost-agents",
+    view: "cost_monitor_zaip_agents",
+    headers: COST_GROUP_EXPORT_COLUMNS,
+    map: exportCostGroupRows,
+  },
+  {
+    name: "cost-models",
+    view: "cost_monitor_models",
+    headers: COST_GROUP_EXPORT_COLUMNS,
+    map: exportCostGroupRows,
+  },
+  {
+    name: "cost-providers",
+    view: "cost_monitor_providers",
+    headers: COST_GROUP_EXPORT_COLUMNS,
+    map: exportCostGroupRows,
+  },
+  {
+    name: "operations-work-list",
+    view: "operations_work_list",
+    headers: WORK_EXPORT_COLUMNS,
+    map: exportWorkRows,
+  },
+  {
+    name: "operations-work-kanban",
+    view: "operations_work_kanban",
+    headers: WORK_EXPORT_COLUMNS,
+    map: exportWorkRows,
+  },
+  {
+    name: "operations-executions",
+    view: "operations_executions",
+    headers: EXECUTION_EXPORT_COLUMNS,
+    map: exportExecutionRows,
+  },
+  {
+    name: "operations-runs",
+    view: "operations_agent_invocations",
+    headers: AGENT_INVOCATION_EXPORT_COLUMNS,
+    map: exportAgentInvocationRows,
+  },
+  {
+    name: "operations-conversations",
+    view: "operations_conversations",
+    headers: CONVERSATION_EXPORT_COLUMNS,
+    map: exportConversationRows,
+  },
+  {
+    name: "operations-changes",
+    view: "operations_changes",
+    headers: CHANGE_EXPORT_COLUMNS,
+    map: (rows) =>
+      rows.map((row) =>
+        Object.fromEntries(CHANGE_EXPORT_COLUMNS.map((key) => [key, row[key] ?? null])),
+      ),
+  },
+  {
+    name: "operations-decisions",
+    view: "operations_decisions",
+    headers: DECISION_EXPORT_COLUMNS,
+    map: (rows) =>
+      rows.map((row) =>
+        Object.fromEntries(DECISION_EXPORT_COLUMNS.map((key) => [key, row[key] ?? null])),
+      ),
+  },
+  {
+    name: "operations-daily",
+    view: "operations_daily",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+  {
+    name: "operations-monthly",
+    view: "operations_monthly",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+  {
+    name: "operations-annual",
+    view: "operations_annual",
+    headers: PERIOD_EXPORT_COLUMNS,
+    map: exportRowsWithDurationHours,
+  },
+];
+
+describe.skipIf(!enabled)("runtime XLSX exports", () => {
+  it("writes and reopens every eligible XLSX with rows and no wholly empty column", async () => {
+    const root = join(tmpdir(), "zaip-aios");
+    const sessionPaths = await Promise.all(
+      readdirSync(root)
+        .filter((name) => name.startsWith("dashboard-sqlite-"))
+        .map(async (name) => {
+          const path = join(root, name, "dashboard-sqlite-session.json");
+          return { path, modified: (await stat(path).catch(() => null))?.mtimeMs ?? 0 };
+        }),
+    );
+    const sessionPath = sessionPaths.sort((left, right) => right.modified - left.modified)[0]?.path;
+    expect(sessionPath).toBeDefined();
+    const session = JSON.parse(await readFile(sessionPath!, "utf8")) as {
+      port: number;
+      token: string;
+    };
+    const output = join(process.cwd(), "..", "..", "..", "..", ".local", "dashboard-export-e2e");
+    await mkdir(output, { recursive: true });
+    for (const item of cases) {
+      const source: Row[] = [];
+      for (let offset = 0; ; ) {
+        const response = await fetch(
+          `http://127.0.0.1:${session.port}/api/v2/sqlite-views?view=${item.view}&offset=${offset}&limit=100`,
+          { headers: { "x-zaip-session": session.token } },
+        );
+        expect(response.ok, item.view).toBe(true);
+        const page = (await response.json()) as { rows: Row[]; total_count: number };
+        source.push(...page.rows);
+        offset += page.rows.length;
+        if (offset >= page.total_count) break;
+        expect(page.rows.length, `${item.view} pagination`).toBeGreaterThan(0);
+      }
+      const rows = item.map(source);
+      const chunks: Uint8Array[] = [];
+      await exportSnapshotToXlsxParts({
+        snapshot: createExportSnapshot({
+          id: item.name,
+          createdAt: new Date().toISOString(),
+          view: item.name,
+          filters: {},
+          totalRows: rows.length,
+          pages: async function* () {
+            yield rows;
+          },
+        }),
+        headers: item.headers,
+        writable: () => ({
+          ready: Promise.resolve(),
+          write: async (chunk) => {
+            chunks.push(chunk);
+          },
+          close: async () => {},
+        }),
+      });
+      const path = join(output, `${item.name}.xlsx`);
+      await writeFile(path, Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))));
+      const workbook = new ExcelJS.Workbook();
+      await workbook.xlsx.load(await readFile(path));
+      expect(workbook.worksheets[0]?.rowCount, item.name).toBe(rows.length + 1);
+      const empty = item.headers.filter(
+        (header) =>
+          rows.length > 0 &&
+          rows.every(
+            (row) => row[header] === null || row[header] === undefined || row[header] === "",
+          ),
+      );
+      expect(empty, `${item.name} columns`).toEqual([]);
+    }
+  }, 120_000);
+});

package/templates/.agents/dashboard/modules/operations/src/react/macro-planning-dialog-content.css

@@ -0,0 +1,49 @@
+.operations-macro-document {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  gap: 12px;
+  padding: 13px 15px;
+  border: 1px solid rgba(148, 163, 184, 0.12);
+  border-radius: 14px;
+  color: #7890aa;
+  background: rgba(12, 20, 34, 0.52);
+}
+
+.operations-macro-document div {
+  display: grid;
+  min-width: 0;
+  gap: 4px;
+}
+
+.operations-macro-document span {
+  font-size: 0.63rem;
+  font-weight: 750;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.operations-macro-document code {
+  overflow: hidden;
+  color: #a4b8cf;
+  font-size: 0.69rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.operations-macro-empty {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  min-height: 92px;
+  border: 1px dashed rgba(var(--macro-accent-rgb), 0.22);
+  border-radius: 16px;
+  color: #8193aa;
+  background: rgba(var(--macro-accent-rgb), 0.025);
+}
+
+.operations-macro-empty p {
+  margin: 0;
+  font-size: 0.78rem;
+}

package/templates/.agents/dashboard/modules/operations/src/react/macro-planning-dialog.css

@@ -315,6 +315,99 @@
   border-top: 1px solid rgba(148, 163, 184, 0.14);
   border-bottom: 0;
 }
+.operations-prd-document-loading,
+.operations-prd-document-error {
+  display: grid;
+  gap: 22px;
+  border: 1px solid rgba(187, 167, 255, 0.2);
+  border-radius: 16px;
+  padding: 22px;
+  background: linear-gradient(135deg, rgba(187, 167, 255, 0.09), rgba(12, 20, 34, 0.28));
+}
+.operations-prd-document-loading-copy {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+}
+.operations-prd-document-loading-copy strong,
+.operations-prd-document-error strong {
+  color: #edf4ff;
+  font-size: 0.88rem;
+}
+.operations-prd-document-loading-copy p,
+.operations-prd-document-error p {
+  margin: 4px 0 0;
+  color: #8da0b8;
+  font-family: inherit;
+  font-size: 0.76rem;
+}
+.operations-prd-document-spinner {
+  flex: 0 0 auto;
+  color: #bba7ff;
+  animation: operations-document-spin 1s linear infinite;
+}
+.operations-prd-document-skeleton {
+  display: grid;
+  gap: 10px;
+}
+.operations-prd-document-skeleton i {
+  display: block;
+  height: 11px;
+  border-radius: 999px;
+  background: linear-gradient(
+    90deg,
+    rgba(148, 163, 184, 0.1),
+    rgba(187, 167, 255, 0.25),
+    rgba(148, 163, 184, 0.1)
+  );
+  background-size: 220% 100%;
+  animation: operations-document-shimmer 1.5s ease-in-out infinite;
+}
+.operations-prd-document-skeleton i:nth-child(2) {
+  width: 88%;
+  animation-delay: 90ms;
+}
+.operations-prd-document-skeleton i:nth-child(3) {
+  width: 72%;
+  animation-delay: 180ms;
+}
+.operations-prd-document-skeleton i:nth-child(4) {
+  width: 82%;
+  animation-delay: 270ms;
+}
+.operations-prd-document-error {
+  border-color: rgba(251, 146, 60, 0.36);
+}
+.operations-prd-document-error button {
+  display: inline-flex;
+  width: fit-content;
+  align-items: center;
+  gap: 7px;
+  border: 1px solid rgba(187, 167, 255, 0.36);
+  border-radius: 9px;
+  padding: 8px 11px;
+  color: #e8e5ff;
+  background: rgba(187, 167, 255, 0.1);
+  cursor: pointer;
+  font-size: 0.75rem;
+  font-weight: 750;
+}
+@keyframes operations-document-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@keyframes operations-document-shimmer {
+  to {
+    background-position: -220% 0;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .operations-prd-document-spinner,
+  .operations-prd-document-skeleton i {
+    animation: none;
+  }
+}
 
 .operations-macro-dialog-scroll {
   display: grid;
@@ -700,53 +793,3 @@
   font-weight: 750;
   white-space: nowrap;
 }
-
-.operations-macro-document {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  gap: 12px;
-  padding: 13px 15px;
-  border: 1px solid rgba(148, 163, 184, 0.12);
-  border-radius: 14px;
-  color: #7890aa;
-  background: rgba(12, 20, 34, 0.52);
-}
-
-.operations-macro-document div {
-  display: grid;
-  min-width: 0;
-  gap: 4px;
-}
-
-.operations-macro-document span {
-  font-size: 0.63rem;
-  font-weight: 750;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
-.operations-macro-document code {
-  overflow: hidden;
-  color: #a4b8cf;
-  font-size: 0.69rem;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.operations-macro-empty {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 10px;
-  min-height: 92px;
-  border: 1px dashed rgba(var(--macro-accent-rgb), 0.22);
-  border-radius: 16px;
-  color: #8193aa;
-  background: rgba(var(--macro-accent-rgb), 0.025);
-}
-
-.operations-macro-empty p {
-  margin: 0;
-  font-size: 0.78rem;
-}

package/templates/.agents/dashboard/modules/operations/src/react/manual-work-priority.test.ts

@@ -0,0 +1,82 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { mergeManualWorkOrder, openWorkCardLabel, sortWorkItems } from "./UnifiedWorkBoard.js";
+
+const board = readFileSync(new URL("UnifiedWorkBoard.tsx", import.meta.url), "utf8");
+const app = readFileSync(new URL("../../../../apps/frontend/src/App.tsx", import.meta.url), "utf8");
+const priorityHandler = app.slice(
+  app.indexOf("onPriorityChange={async"),
+  app.indexOf("onPeriodChange="),
+);
+const styles = readFileSync(new URL("unified-work-board.css", import.meta.url), "utf8");
+const requirements = readFileSync(
+  new URL("../../../../../requirements/kanban-dashboard.md", import.meta.url),
+  "utf8",
+);
+
+describe("manual work priority interactions", () => {
+  it("updates locally without waiting for a full projection refresh and restores the previous order on failure", () => {
+    expect(priorityHandler).toContain("await api.saveWorkPriority(itemIds)");
+    expect(priorityHandler).toContain(
+      "setError(cause instanceof Error ? cause.message : String(cause))",
+    );
+    expect(priorityHandler).not.toContain("await refresh();");
+    expect(board).toContain("setOptimisticOrder(nextOrder)");
+    expect(board).toContain("setOptimisticOrder(previous)");
+  });
+
+  it("supports drag/drop and separate keyboard controls without nesting controls inside a button", () => {
+    expect(board).toContain("draggable");
+    expect(board).toContain("onDragStart");
+    expect(board).toMatch(/onDrop=\{\s*stage === "ready"\s*\?\s*\(event\)/);
+    expect(board).toContain('locale === "pt-BR" ? "Mover acima" : "Move up"');
+    expect(board).toContain('locale === "pt-BR" ? "Mover abaixo" : "Move down"');
+    expect(board).toContain('className="operations-work-card-open"');
+    expect(board).toContain("<article");
+    expect(board).not.toContain('role="button"');
+  });
+
+  it("merges a column reorder into the global queue without replacing other ranks", () => {
+    const work = (id: string) => ({ kind: "task", row: { id } }) as never;
+    expect(
+      mergeManualWorkOrder(
+        [work("PRD"), work("A"), work("SPEC"), work("B")],
+        [work("A"), work("B")],
+        [work("B"), work("A")],
+      ),
+    ).toEqual(["PRD", "B", "SPEC", "A"]);
+  });
+
+  it("renders the queued order immediately from the accepted priority contract", () => {
+    const work = (id: string) => ({ kind: "task", row: { id, updated_at: "" } }) as never;
+    expect(
+      sortWorkItems([work("A"), work("B"), work("C")], ["C", "A", "B"]).map((item) => item.row.id),
+    ).toEqual(["C", "A", "B"]);
+  });
+
+  it("localizes the accessible card action label", () => {
+    expect(openWorkCardLabel("pt-BR", "Fila")).toBe("Abrir Fila");
+    expect(openWorkCardLabel("en-US", "Queue")).toBe("Open Queue");
+  });
+
+  it("styles only the actual interactive surfaces as clickable and retains the historical AC sequence", () => {
+    expect(styles).toContain(".operations-work-card {\n  cursor: default;");
+    expect(styles).toContain(".operations-work-card-open {\n  display: flex;");
+    expect(styles).toContain(".operations-work-card-open:hover > strong");
+    expect(styles).toContain(".operations-work-reorder button {");
+    expect(styles).toContain(".operations-work-order,");
+    expect(styles).toContain(
+      ".operations-work-reorder {\n  position: absolute;\n  top: 10px;\n  right: 10px;",
+    );
+    expect(board).toContain(
+      "<span className={`operations-work-kind is-${item.kind}`}>{kindLabel}</span>",
+    );
+    expect(board).toContain('<span className="operations-work-order">#{order}</span>');
+    expect(requirements.indexOf("`AC-DASH-001-12`:")).toBeLessThan(
+      requirements.indexOf("`AC-DASH-001-13`:"),
+    );
+    expect(requirements.indexOf("`AC-DASH-001-13`:")).toBeLessThan(
+      requirements.indexOf("`AC-DASH-001-14`: o Kanban"),
+    );
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/react/operation-date-range.test.ts

@@ -1,21 +1,37 @@
 import { describe, expect, it } from "vitest";
 import {
   dateRangeForPreset,
+  initialOperationsDateRange,
   initialTaskDateRange,
   isDateInOperationPreset,
+  isRunInOperationPreset,
   isTaskCreatedInRange,
 } from "./operation-date-range.js";
 
 const today = new Date(2026, 6, 14, 12);
 
 describe("operation date ranges", () => {
-  it("starts one day before the earliest Task and ends today", () => {
+  it("starts on the earliest Task day and ends today", () => {
     expect(
       initialTaskDateRange(
         [{ created_at: "2026-07-12T22:00:00.000Z" }, { created_at: "2026-07-10T15:00:00.000Z" }],
         today,
       ),
-    ).toEqual({ start: "2026-07-09", end: "2026-07-14" });
+    ).toEqual({ start: "2026-07-10", end: "2026-07-14" });
+  });
+
+  it("uses the Sao Paulo day for the earliest Task", () => {
+    expect(initialTaskDateRange([{ created_at: "2026-07-10T02:30:00.000Z" }], today)).toEqual({
+      start: "2026-07-09",
+      end: "2026-07-14",
+    });
+  });
+
+  it("uses persisted manifest days for All Time before quick entity details load", () => {
+    expect(initialOperationsDateRange([], ["2026-07-11", "2026-08-06"], today)).toEqual({
+      start: "2026-07-11",
+      end: "2026-08-06",
+    });
   });
 
   it.each([
@@ -46,6 +62,17 @@ describe("operation date ranges", () => {
     expect(isTaskCreatedInRange("2026-07-16T03:00:00.000Z", fifteenth)).toBe(false);
   });
 
+  it("places a Run that starts before and finishes inside a period on its finish day", () => {
+    const augustFirst = { start: "2026-08-01", end: "2026-08-01" };
+    const run = {
+      started_at: "2026-08-01T02:30:00.000Z",
+      finished_at: "2026-08-01T03:30:00.000Z",
+    };
+
+    expect(isRunInOperationPreset(run, "custom", augustFirst)).toBe(true);
+    expect(isDateInOperationPreset(run.started_at, "custom", augustFirst)).toBe(false);
+  });
+
   it("keeps All Time unbounded while explicit This Month stays on the Sao Paulo calendar", () => {
     const july = dateRangeForPreset("this-month", new Date("2026-08-01T02:30:00.000Z"));
     expect(isDateInOperationPreset("2024-01-01T00:00:00.000Z", "all", july)).toBe(true);