@zaip-ai/cli 1.0.8 → 1.3.1

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/index.ts

@@ -1,3 +1,4 @@
+export * from "./DeveloperAttributionPanel.js";
 export * from "./EntityDetailsDialog.js";
 export * from "./EntityTables.js";
 export * from "./export/ExcelExportAction.js";

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from "vitest";
 import {
   displayedDuration,
   elapsedDurationMs,
-  formatLifecycleElapsedDuration,
   formatDisplayedDuration,
+  formatLifecycleElapsedDuration,
   formatOperationDuration,
   operationalDurationMs,
   terminalLifecycleElapsedDurationMs,
@@ -68,9 +68,9 @@ describe("formatOperationDuration", () => {
     });
     expect(running).toEqual({ durationMs: null, provenance: "in_progress" });
     expect(formatDisplayedDuration(running, "pt-BR")).toBe("Em andamento");
-    expect(
-      formatDisplayedDuration({ durationMs: null, provenance: "unavailable" }, "pt-BR"),
-    ).toBe("Sem atribuição temporal");
+    expect(formatDisplayedDuration({ durationMs: null, provenance: "unavailable" }, "pt-BR")).toBe(
+      "Sem atribuição temporal",
+    );
   });
 
   it("keeps terminal lifecycle elapsed separate from observed duration and never uses now", () => {

package/templates/.agents/dashboard/modules/operations/src/react/operation-duration.ts

@@ -39,16 +39,18 @@ export function formatDisplayedDuration(
   value: { durationMs: number | null; provenance: DurationPresentationProvenance },
   locale: OperationsLocale,
 ): string {
-  if (value.provenance === "in_progress") return locale === "pt-BR" ? "Em andamento" : "In progress";
+  if (value.provenance === "in_progress")
+    return locale === "pt-BR" ? "Em andamento" : "In progress";
   if (value.durationMs === null || value.provenance === "unavailable")
     return locale === "pt-BR" ? "Sem atribuição temporal" : "No temporal attribution";
   return formatOperationDuration(value.durationMs, locale);
 }
 
 /** Presentation-only terminal lifecycle fallback; never analytical telemetry. */
-export function displayedDuration(
-  run: OperationalTiming & { status?: string },
-): { durationMs: number | null; provenance: DurationPresentationProvenance } {
+export function displayedDuration(run: OperationalTiming & { status?: string }): {
+  durationMs: number | null;
+  provenance: DurationPresentationProvenance;
+} {
   const factual = operationalDurationMs(run);
   if (factual !== null) return { durationMs: factual, provenance: "factual" };
   if (run.status === "running") return { durationMs: null, provenance: "in_progress" };

package/templates/.agents/dashboard/modules/operations/src/react/operations-coverage-toast.test.ts

@@ -40,9 +40,10 @@ describe("Operations persisted aggregate display", () => {
     const overview = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
 
     expect(overview).toContain("overviewMetrics?.duration_ms ??");
-    expect(overview).toContain(
-      "const totalTokensMetric = overviewMetrics?.tokens ?? allPhaseMetrics.tokens",
-    );
+    expect(overview).toContain("const totalTokensMetric = scopedOverviewMetric(");
+    expect(overview).toContain("selectedMacroTotals?.tokens,");
+    expect(overview).toContain("const totalDurationMetric = scopedOverviewMetric(");
+    expect(overview).toContain("selectedMacroTotals?.durationMs,");
     expect(overview).toContain("const totalCostMetric =");
     expect(overview).toContain(
       "durationMs: totalDurationMetric, tokens: totalTokensMetric, costBrl: totalCostMetric",

package/templates/.agents/dashboard/modules/operations/src/react/operations-date-filters.css

@@ -43,7 +43,7 @@
 }
 
 .operations-toolbar-field > span {
-  color: #64748b;
+  color: var(--muted);
   font-size: 0.51rem;
   font-weight: 700;
   letter-spacing: 0.08em;

package/templates/.agents/dashboard/modules/operations/src/react/operations-global-filters.test.ts

@@ -4,7 +4,10 @@ import { describe, expect, it } from "vitest";
 const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
 const globalFilterPanel = source.slice(
   source.indexOf('<div className="operations-global-filters"'),
-  source.indexOf("filtersActive={Boolean(", source.indexOf('<div className="operations-global-filters"')),
+  source.indexOf(
+    "filtersActive={Boolean(",
+    source.indexOf('<div className="operations-global-filters"'),
+  ),
 );
 
 describe("Operations global filters", () => {

package/templates/.agents/dashboard/modules/operations/src/react/operations-overview-period-filter.test.ts

@@ -5,10 +5,7 @@ import { workListTypeOnViewChange } from "./operations-page-contract.js";
 
 describe("overview period filter", () => {
   it("passes activity-filtered entities and Runs to every overview metric", () => {
-    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
-    const overviewStart = source.indexOf("<OperationsOverview");
-    const overviewEnd = source.indexOf("/>", overviewStart);
-    const overview = source.slice(overviewStart, overviewEnd);
+    const overview = readFileSync(new URL("OperationsPageOverview.tsx", import.meta.url), "utf8");
 
     expect(overview).toContain("runs={runs}");
     expect(overview).toContain("tasks={tasks}");
@@ -19,13 +16,14 @@ describe("overview period filter", () => {
 
   it("replaces stale Operations content without duplicated period controls or gray bars", () => {
     const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+    const overview = readFileSync(new URL("OperationsPageOverview.tsx", import.meta.url), "utf8");
 
     expect(shouldRenderOperationsContent(true)).toBe(false);
     expect(shouldRenderOperationsContent(false)).toBe(true);
     expect(source).toContain("<OperationsPageLoading locale={locale} />");
     expect(source).not.toContain('className="operations-hero operations-hero-skeleton"');
-    expect(source).toContain('className="operations-content-skeleton"');
-    expect(source).not.toContain('className="operations-content-skeleton-lines"');
+    expect(overview).toContain('className="operations-content-skeleton"');
+    expect(overview).not.toContain('className="operations-content-skeleton-lines"');
     expect(source).not.toContain('className="operations-loading-period"');
   });
 
@@ -54,13 +52,17 @@ describe("overview period filter", () => {
 
   it("derives all big-number KPIs from the period-filtered global aggregate", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const helpers = readFileSync(
+      new URL("OperationsOverview.helpers.tsx", import.meta.url),
+      "utf8",
+    );
 
     expect(source).toContain("const executionMetrics = executionMetricTotals(runs)");
     expect(source).toContain("overviewMetrics?.duration_ms ?? executionMetrics.durationMs");
     expect(source).not.toContain("effortMetricTotals");
     expect(source).not.toContain("globalLegacyEffortMetricDuration");
     expect(source).toContain("const overviewMetrics = partialOverviewMetrics(data);");
-    expect(source).toContain("return data.summary.overview_metrics;");
+    expect(helpers).toContain("return data.summary.overview_metrics;");
     expect(source).toContain("overviewMetrics?.duration_ms ??");
     expect(source).toContain("overviewMetrics?.tokens ?? allPhaseMetrics.tokens");
     expect(source).toContain("overviewMetrics?.cost_brl ??");
@@ -71,6 +73,10 @@ describe("overview period filter", () => {
 
   it("renders Operations costs in the selected currency from the factual per-Run resolver", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const topPanel = readFileSync(
+      new URL("OperationsOverviewTopPanel.tsx", import.meta.url),
+      "utf8",
+    );
     const periods = readFileSync(new URL("PeriodSummaryTable.tsx", import.meta.url), "utf8");
 
     expect(source).toContain('currency: "BRL" | "USD"');
@@ -78,7 +84,7 @@ describe("overview period filter", () => {
     expect(source).toContain("formatCurrency(averageCost, currency, locale)");
     expect(source).toContain("formatRoundedCurrency(totalCostMetric, currency, locale)");
     expect(source).toContain("const topEntitiesCost =");
-    expect(source).toContain("formatCurrency(topEntitiesCost, currency, locale)");
+    expect(topPanel).toContain("formatCurrency(topCost, currency, locale)");
     expect(periods).toContain("resolveRunCost?: ((runId: string) => number | null)");
     expect(periods).toContain("formatCurrency(row.costBrl, currency, locale)");
     expect(periods).toContain('manifestDailyPeriods === undefined || currency === "USD"');
@@ -96,7 +102,7 @@ describe("overview period filter", () => {
     expect(app).toContain('currency === "USD" ? run.estimated_usd : run.estimated_brl');
     expect(app).toContain("resolveRunCost={");
     expect(app).toContain('if (currency !== "USD" || costs?.currency === currency) return;');
-    expect(app).toContain('void loadCostSummary();');
+    expect(app).toContain("void loadCostSummary();");
   });
 
   it("loads the quick overview first while retaining the detail hydration fallback", () => {
@@ -160,11 +166,15 @@ describe("overview period filter", () => {
 
   it("scopes task and macro metrics to the active overview entity kind", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const helpers = readFileSync(
+      new URL("OperationsOverview.helpers.tsx", import.meta.url),
+      "utf8",
+    );
 
     expect(source).toContain("const selectedMetricRuns = runsForOverviewView");
-    expect(source).toContain("run.task_id !== null && taskIds.has(run.task_id)");
-    expect(source).toContain("run.spec_id !== null && macroIds.has(run.spec_id)");
-    expect(source).toContain("run.prd_id !== null && macroIds.has(run.prd_id)");
+    expect(helpers).toContain("run.task_id !== null && taskIds.has(run.task_id)");
+    expect(helpers).toContain("run.spec_id !== null && macroIds.has(run.spec_id)");
+    expect(helpers).toContain("run.prd_id !== null && macroIds.has(run.prd_id)");
   });
 
   it("keeps the overview projection run-free while details load separately", () => {

package/templates/.agents/dashboard/modules/operations/src/react/operations-overview.css

@@ -384,6 +384,10 @@
   border-radius: 10px 10px 3px 3px;
   background: linear-gradient(180deg, #00b0f0, #60a5fa);
 }
+.operations-run-bar.is-duration-unavailable i {
+  min-height: 0;
+  background: rgba(112, 137, 165, 0.36);
+}
 .operations-run-bars span {
   display: grid;
   min-height: 2.4em;

package/templates/.agents/dashboard/modules/operations/src/react/operations-overview.status-cards.test.ts

@@ -22,6 +22,6 @@ describe("OperationsOverview status cards", () => {
     expect(source).toContain("onLoadMore(items.length)");
     expect(source).toContain('aria-busy="true"');
     expect(source).toContain('role="alert"');
-    expect(source).toContain("Nenhum${kind === \"task\" ? \"a\" : \"\"}");
+    expect(source).toContain('Nenhum${kind === "task" ? "a" : ""}');
   });
 });

package/templates/.agents/dashboard/modules/operations/src/react/operations-page-contract.ts

@@ -1,10 +1,16 @@
 import type { ReactNode } from "react";
-import type { DashboardTaskProjection, MacroProjection, OperationsProjection } from "../contracts.js";
+import type {
+  DashboardTaskProjection,
+  MacroProjection,
+  OperationsProjection,
+} from "../contracts.js";
 import type { OperationDatePreset, OperationDateRange } from "./operation-date-range.js";
 import type { OperationsView } from "./operations-page-filters.js";
 import type { OperationsLocale } from "./status-labels.js";
 import type { WorkStage, WorkTypeFilter } from "./work-board-model.js";
 
+export type OperationsExportView = OperationsView;
+
 export interface DashboardGlobalFilters {
   query: string;
   datePreset: OperationDatePreset;
@@ -12,7 +18,13 @@ export interface DashboardGlobalFilters {
 }
 
 export type OverviewStatusKind = "task" | "spec" | "prd";
-export type OverviewClassification = "lite" | "standard" | "critical" | "empty" | "structured" | "rework";
+export type OverviewClassification =
+  | "lite"
+  | "standard"
+  | "critical"
+  | "empty"
+  | "structured"
+  | "rework";
 
 /** A remounted Trabalho (Lista) selector always starts on "all". */
 export function workListTypeOnViewChange(nextView: OperationsView): WorkTypeFilter | null {
@@ -33,7 +45,10 @@ export interface OperationsPageProps {
   alternateContent?: ReactNode | ((filters: DashboardGlobalFilters) => ReactNode);
   boardTotals?: Partial<Record<WorkStage, number>>;
   boardKindTotals?: Partial<
-    Record<WorkStage, { all: number; task: number; prd: number; spec: number }>
+    Record<
+      WorkStage,
+      { all: number; task: number; "standalone-task": number; prd: number; spec: number }
+    >
   >;
   boardStates?: Partial<Record<WorkStage, { loading: boolean; error: string | null }>>;
   /** Immutable, filtered board snapshot supplied by the composition root for XLSX. */
@@ -48,6 +63,24 @@ export interface OperationsPageProps {
       pages: () => AsyncGenerator<readonly Record<string, unknown>[]>;
     }>;
   };
+  /** Immutable, filtered full table collection for every Operations XLSX view. */
+  detailExportSource?: (
+    view: OperationsExportView,
+    filters: {
+      query: string;
+      status: string;
+      risk: string;
+      origin: string;
+      kind?: string;
+    },
+  ) =>
+    | {
+        prepare: () => Promise<{
+          totalRows: number;
+          pages: () => AsyncGenerator<readonly Record<string, unknown>[]>;
+        }>;
+      }
+    | undefined;
   capabilityNavigation: ReactNode;
   data: OperationsProjection;
   dashboardTitle?: string;
@@ -60,6 +93,8 @@ export interface OperationsPageProps {
   onOpenTask: (taskId: string) => Promise<boolean>;
   onPriorityChange: (itemIds: readonly string[]) => Promise<void>;
   onDetailDataRequest?: (view: OperationsView) => void;
+  /** Lazy hydration for the extended SPEC/PRD aggregate behind overview cards. */
+  onLoadMacroMetrics?: () => void;
   entityPage?: {
     offset: number;
     total: number | null;
@@ -87,6 +122,8 @@ export interface OperationsPageProps {
   }) => void;
   onBoardTypeChange?: (kind: WorkTypeFilter) => void;
   onWorkListTypeChange?: (kind: WorkTypeFilter) => void;
+  onWorkListPageChange?: (offset: number) => void;
+  workListPage?: import("./PagedWorkList.js").PagedWorkListPage;
   onLoadMoreBoard?: (stage: WorkStage) => void;
   /** A dedicated, server-filtered status collection; never a mixed Kanban page. */
   statusPage?: (stage: WorkStage, kind: OverviewStatusKind) => OverviewStatusPage | undefined;
@@ -115,9 +152,19 @@ export interface OperationsPageProps {
    */
   factualCostTotal?: number | null | undefined;
   /** Factual Cost Monitor rows matching the active global period. */
-  factualCostPeriods?: Partial<
-    Record<"day" | "month" | "year", readonly { key: string; estimated_usd: number | null; estimated_brl: number | null }[]>
-  > | undefined;
+  factualCostPeriods?:
+    | Partial<
+        Record<
+          "day" | "month" | "year",
+          readonly {
+            key: string;
+            estimated_usd: number | null;
+            estimated_brl: number | null;
+            duration_ms: number | null;
+          }[]
+        >
+      >
+    | undefined;
 }
 
 /** Single-source period contract for App-controlled Operations navigation. */

package/templates/.agents/dashboard/modules/operations/src/react/operations-view-order.test.ts

@@ -10,6 +10,7 @@ describe("operations tab navigation", () => {
 
     expect(navigation).toContain('"work-kanban"');
     expect(navigation).toContain('"work-list"');
+    expect(navigation).not.toContain('"developers"');
     expect(navigation).not.toContain('"tasks"');
     expect(navigation).not.toContain('"specs"');
     expect(navigation).not.toContain('"prds"');
@@ -25,10 +26,7 @@ describe("operations tab navigation", () => {
   });
 
   it("uses the simplified Portuguese labels", () => {
-    const labels = readFileSync(
-      new URL("operations-view-labels.ts", import.meta.url),
-      "utf8",
-    );
+    const labels = readFileSync(new URL("operations-view-labels.ts", import.meta.url), "utf8");
 
     expect(labels).toContain('"work-kanban": "Visão de Quadro (Kanban)"');
     expect(labels).toContain('"work-list": "Visão de Lista"');