@zaip-ai/cli 1.0.7 → 1.0.8

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);

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

@@ -26,10 +26,22 @@ export function initialTaskDateRange(
     Number.POSITIVE_INFINITY,
   );
   const start = Number.isFinite(earliestTimestamp) ? new Date(earliestTimestamp) : today;
-  start.setUTCDate(start.getUTCDate() - 1);
   return { start: toDateInputValue(start), end: toDateInputValue(today) };
 }
 
+/** Quick projections omit entity rows, but retain manifest day keys for All Time. */
+export function initialOperationsDateRange(
+  tasks: readonly { created_at: string }[],
+  manifestDays: readonly string[],
+  today = new Date(),
+): OperationDateRange {
+  if (tasks.length > 0) return initialTaskDateRange(tasks, today);
+  const days = manifestDays.filter((day) => /^\d{4}-\d{2}-\d{2}$/.test(day)).sort();
+  return days.length === 0
+    ? initialTaskDateRange(tasks, today)
+    : { start: days[0]!, end: days.at(-1)! };
+}
+
 export function dateRangeForPreset(
   preset: Exclude<OperationDatePreset, "all" | "custom">,
   today = new Date(),
@@ -96,6 +108,15 @@ export function isDateInOperationPreset(
   return preset === "all" || isDateInRange(value, dateRange);
 }
 
+/** Matches the server projection contract: a completed Run belongs to its finish day. */
+export function isRunInOperationPreset(
+  run: { started_at: string; finished_at: string | null },
+  preset: OperationDatePreset,
+  dateRange: OperationDateRange,
+): boolean {
+  return isDateInOperationPreset(run.finished_at ?? run.started_at, preset, dateRange);
+}
+
 function range(start: Date, end: Date): OperationDateRange {
   return { start: toDateInputValue(start), end: toDateInputValue(end) };
 }

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

@@ -1,5 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { formatOperationDuration, operationalDurationMs } from "./operation-duration.js";
+import {
+  displayedDuration,
+  elapsedDurationMs,
+  formatLifecycleElapsedDuration,
+  formatDisplayedDuration,
+  formatOperationDuration,
+  operationalDurationMs,
+  terminalLifecycleElapsedDurationMs,
+} from "./operation-duration.js";
 
 describe("formatOperationDuration", () => {
   it("preserves unavailable and observed zero as different states", () => {
@@ -7,13 +15,78 @@ describe("formatOperationDuration", () => {
     expect(formatOperationDuration(0, "pt-BR")).toBe("0 seg");
   });
 
-  it("uses lifecycle interval only as operational list time", () => {
+  it("keeps lifecycle elapsed separate from analytical duration", () => {
+    const run = {
+      duration_ms: 3_600_000,
+      source_duration_ms: null,
+      started_at: "2026-07-28T10:00:00Z",
+      finished_at: "2026-07-28T11:00:00Z",
+    };
+    expect(operationalDurationMs(run)).toBeNull();
+    expect(elapsedDurationMs(run)).toBe(3_600_000);
+  });
+
+  it("uses an observed source duration including zero", () => {
     expect(
       operationalDurationMs({
-        duration_ms: null,
+        duration_ms: 3_600_000,
+        source_duration_ms: 0,
         started_at: "2026-07-28T10:00:00Z",
         finished_at: "2026-07-28T11:00:00Z",
       }),
-    ).toBe(3_600_000);
+    ).toBe(0);
+  });
+
+  it("uses lifecycle elapsed only as an explicitly labelled terminal fallback", () => {
+    expect(
+      displayedDuration({
+        status: "completed",
+        duration_ms: null,
+        source_duration_ms: null,
+        started_at: "2026-07-28T10:00:00Z",
+        finished_at: "2026-07-28T10:01:30Z",
+      }),
+    ).toEqual({ durationMs: 90_000, provenance: "lifecycle_elapsed" });
+    expect(
+      displayedDuration({
+        status: "completed",
+        duration_ms: 60_000,
+        source_duration_ms: 60_000,
+        started_at: "2026-07-28T10:00:00Z",
+        finished_at: "2026-07-28T10:10:00Z",
+      }),
+    ).toEqual({ durationMs: 60_000, provenance: "factual" });
+  });
+
+  it("labels a running Run without factual duration instead of calling it unavailable", () => {
+    const running = displayedDuration({
+      status: "running",
+      duration_ms: null,
+      source_duration_ms: null,
+      started_at: "2026-07-28T10:00:00Z",
+      finished_at: null,
+    });
+    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");
+  });
+
+  it("keeps terminal lifecycle elapsed separate from observed duration and never uses now", () => {
+    const terminal = {
+      status: "completed",
+      duration_ms: 60_000,
+      source_duration_ms: 60_000,
+      started_at: "2026-07-28T10:00:00Z",
+      finished_at: "2026-07-28T12:00:00Z",
+    };
+    expect(terminalLifecycleElapsedDurationMs(terminal)).toBe(7_200_000);
+    expect(formatLifecycleElapsedDuration(null, "pt-BR")).toBe(
+      formatOperationDuration(null, "pt-BR"),
+    );
+    expect(
+      terminalLifecycleElapsedDurationMs({ ...terminal, status: "running", finished_at: null }),
+    ).toBeUndefined();
   });
 });

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

@@ -2,9 +2,9 @@ import { formatDurationMs } from "@zaip-ai/dashboard-ui";
 import type { OperationsLocale } from "./status-labels.js";
 
 export interface OperationalTiming {
-  duration_ms: number | null;
+  duration_ms?: number | null;
   source_duration_ms?: number | null;
-  started_at: string;
+  started_at: string | null;
   finished_at: string | null;
 }
 
@@ -16,12 +16,72 @@ export function formatOperationDuration(value: number | null, locale: Operations
 
 /** List/detail elapsed time; analytical duration_ms remains unchanged for KPIs. */
 export function operationalDurationMs(run: OperationalTiming): number | null {
-  if (typeof run.source_duration_ms === "number") return run.source_duration_ms;
-  if (typeof run.duration_ms === "number") return run.duration_ms;
-  if (run.finished_at === null) return null;
+  if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0)
+    return run.source_duration_ms;
+  const provenance = (run as OperationalTiming & { duration_provenance?: string })
+    .duration_provenance;
+  if (
+    typeof run.duration_ms === "number" &&
+    run.duration_ms >= 0 &&
+    (provenance === "observed" || provenance === "reconciled" || provenance === "legacy_inferred")
+  )
+    return run.duration_ms;
+  return null;
+}
+
+export type DurationPresentationProvenance =
+  | "factual"
+  | "lifecycle_elapsed"
+  | "in_progress"
+  | "unavailable";
+
+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.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 } {
+  const factual = operationalDurationMs(run);
+  if (factual !== null) return { durationMs: factual, provenance: "factual" };
+  if (run.status === "running") return { durationMs: null, provenance: "in_progress" };
+  const lifecycle = terminalLifecycleElapsedDurationMs({ ...run, status: run.status ?? "" });
+  return lifecycle === undefined || lifecycle === null
+    ? { durationMs: null, provenance: "unavailable" }
+    : { durationMs: lifecycle, provenance: "lifecycle_elapsed" };
+}
+
+/**
+ * Lifecycle elapsed time is operational context, never an analytical metric.
+ * Callers must label this separately as Tempo decorrido.
+ */
+export function elapsedDurationMs(run: OperationalTiming): number | null {
+  if (run.started_at === null || run.finished_at === null) return null;
   const started = Date.parse(run.started_at);
   const finished = Date.parse(run.finished_at);
   return Number.isFinite(started) && Number.isFinite(finished) && finished >= started
     ? finished - started
     : null;
 }
+
+/** `undefined` is ineligible; `null` is a terminal record without valid timestamps. */
+export function terminalLifecycleElapsedDurationMs(
+  row: OperationalTiming & { status: string },
+): number | null | undefined {
+  if (!["completed", "failed", "cancelled"].includes(row.status)) return undefined;
+  return elapsedDurationMs(row);
+}
+
+export function formatLifecycleElapsedDuration(
+  value: number | null | undefined,
+  locale: OperationsLocale,
+): string {
+  return value === undefined ? "—" : formatOperationDuration(value, locale);
+}

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

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { overviewMetricTotals } from "../server/build-operations-projection.js";
+
+describe("Operations persisted aggregate display", () => {
+  it("removes the telemetry notice and its styling entirely", () => {
+    const overview = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const styles = readFileSync(new URL("operations-overview.css", import.meta.url), "utf8");
+
+    expect(overview).not.toContain("operations-coverage-toast");
+    expect(styles).not.toContain("operations-coverage-toast");
+  });
+
+  it("keeps legacy duration unavailable while preserving zero-valued tokens and cost", () => {
+    const totals = overviewMetricTotals(
+      [
+        {
+          id: "RUN-LEGACY",
+          started_at: "2026-08-03T12:00:00.000Z",
+          source_duration_ms: null,
+          duration_ms: 125,
+          duration_provenance: "legacy_inferred" as const,
+          usage: { total: { tokens: { total: 0 }, cost: { brl: 0 } } },
+        },
+        {
+          id: "RUN-UNKNOWN",
+          started_at: "2026-08-03T12:01:00.000Z",
+          source_duration_ms: null,
+          duration_ms: null,
+          usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+        },
+      ],
+      { from: "2026-08-03T00:00:00.000Z", to: "2026-08-03T23:59:59.999Z" },
+    );
+
+    expect(totals).toMatchObject({ duration_ms: null, tokens: 0, cost_brl: 0 });
+  });
+
+  it("preserves unavailable aggregate totals instead of rendering coerced zeroes", () => {
+    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 totalCostMetric =");
+    expect(overview).toContain(
+      "durationMs: totalDurationMetric, tokens: totalTokensMetric, costBrl: totalCostMetric",
+    );
+    expect(overview).toContain("formatEntityDuration(averageDuration, locale)");
+    expect(overview).not.toContain("allPhaseMetrics.tokens ?? 0");
+    expect(overview).not.toContain("executionMetrics.durationMs ?? 0");
+  });
+});

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

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+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"')),
+);
+
+describe("Operations global filters", () => {
+  it("keeps only period, dates, and reset in the dashboard header panel", () => {
+    expect(globalFilterPanel).toContain("<OperationDateFilters");
+    expect(globalFilterPanel).toContain("Limpar filtros");
+    expect(globalFilterPanel).not.toContain('"Tipo" : "Type"');
+    expect(globalFilterPanel).not.toContain("<span>Status</span>");
+    expect(globalFilterPanel).not.toContain('"Risco" : "Risk"');
+    expect(globalFilterPanel).not.toContain('"Origem da tarefa" : "Task origin"');
+  });
+});

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

@@ -1,44 +1,142 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
+import { resolveOperationsPeriodControl, shouldRenderOperationsContent } from "./OperationsPage.js";
+import { workListTypeOnViewChange } from "./operations-page-contract.js";
 
 describe("overview period filter", () => {
-  it("passes the period-filtered runs to every overview metric", () => {
+  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);
 
     expect(overview).toContain("runs={runs}");
+    expect(overview).toContain("tasks={tasks}");
+    expect(overview).toContain("specs={specs}");
+    expect(overview).toContain("prds={prds}");
     expect(overview).not.toContain("runs={data.runs}");
   });
 
-  it("derives all monetary and duration KPIs from the period-filtered Runs", () => {
+  it("replaces stale Operations content without duplicated period controls or gray bars", () => {
+    const source = readFileSync(new URL("OperationsPage.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(source).not.toContain('className="operations-loading-period"');
+  });
+
+  it("keeps the App-controlled Yesterday selection across a loading render without remount state", () => {
+    const yesterday = { start: "2026-08-07", end: "2026-08-07" };
+    const controlled = resolveOperationsPeriodControl({
+      datePreset: "yesterday",
+      dateRange: yesterday,
+      fallbackPreset: "today",
+      fallbackRange: { start: "2026-08-08", end: "2026-08-08" },
+    });
+    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+
+    expect(controlled).toMatchObject({
+      controlled: true,
+      datePreset: "yesterday",
+      dateRange: yesterday,
+    });
+    expect(source).toContain("datePreset: controlledDatePreset");
+    expect(source).toContain("dateRange: controlledDateRange");
+    expect(source).toContain("onDateChange");
+    expect(source).toContain("const isPeriodControlled = periodControl.controlled;");
+    expect(source).not.toContain('className="operations-loading-period"');
+    expect(shouldRenderOperationsContent(true)).toBe(false);
+  });
+
+  it("derives all big-number KPIs from the period-filtered global aggregate", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
 
     expect(source).toContain("const executionMetrics = executionMetricTotals(runs)");
-    expect(source).toContain("const effortMetrics = effortMetricTotals(runs)");
-    expect(source).toContain("? globalLegacyEffortMetricDuration(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(source).toContain("overviewMetrics?.duration_ms ??");
-    expect(source).toContain("effortMetrics.durationMs");
     expect(source).toContain("overviewMetrics?.tokens ?? allPhaseMetrics.tokens");
+    expect(source).toContain("overviewMetrics?.cost_brl ??");
+    expect(source).toContain("const selectedCurrencyCost =");
     expect(source).not.toContain("data.summary.execution_duration_ms");
     expect(source).not.toContain("data.summary.usage.total");
   });
 
-  it("loads Run detail before rendering filterable overview KPIs", () => {
+  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 periods = readFileSync(new URL("PeriodSummaryTable.tsx", import.meta.url), "utf8");
+
+    expect(source).toContain('currency: "BRL" | "USD"');
+    expect(source).toContain("const selectedCurrencyCost =");
+    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(periods).toContain("resolveRunCost?: ((runId: string) => number | null)");
+    expect(periods).toContain("formatCurrency(row.costBrl, currency, locale)");
+    expect(periods).toContain('manifestDailyPeriods === undefined || currency === "USD"');
+  });
+
+  it("pairs the global language selector with its currency before passing it to Operations", () => {
     const app = readFileSync(
       new URL("../../../../apps/frontend/src/App.tsx", import.meta.url),
       "utf8",
     );
 
-    expect(app).toContain("const projection = await api.operations(period);");
-    expect(app).toContain("operationsDetailLoadedRef.current = true;");
-    expect(app).not.toContain("api.operations(period, !operationsDetailLoaded)");
-    expect(app).toContain("const requestVersion = ++refreshVersion.current;");
-    expect(app).toContain(
-      "const isCurrentRequest = () => requestVersion === refreshVersion.current;",
+    expect(app).toContain("const changeDashboardLocale = useCallback");
+    expect(app).toContain('setCurrency(next === "en-US" ? "USD" : "BRL")');
+    expect(app).toContain("onLocaleChange={changeDashboardLocale}");
+    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();');
+  });
+
+  it("loads the quick overview first while retaining the detail hydration fallback", () => {
+    const app = readFileSync(
+      new URL("../../../../apps/frontend/src/App.tsx", import.meta.url),
+      "utf8",
     );
+    const hydration = readFileSync(
+      new URL("../../../../apps/frontend/src/operations-detail-hydration.ts", import.meta.url),
+      "utf8",
+    );
+    const effects = readFileSync(
+      new URL("../../../../apps/frontend/src/use-app-effects.ts", import.meta.url),
+      "utf8",
+    );
+
+    expect(app).toContain('api.operations(period, "quick",');
+    expect(app).toContain("const requestVersion = ++refreshVersion.current;");
+    expect(app).toContain("operationsDetailLoadedRef.current = true;");
+    expect(app).toContain("isCurrentDashboardRequest(requestVersion, refreshVersion.current)");
     expect(app).toContain("if (!isCurrentRequest()) return;");
+    expect(app).toContain("useAppEffects({");
+    expect(effects).toContain("shouldHydrateOperationsDetails(");
+    expect(effects).toContain("scheduleOperationsDetail(async (signal)");
+    expect(effects).toContain("await loadOperationsDetails(signal);");
+    expect(app).toContain('api.operations(period, "quick",');
+    expect(app).not.toContain('api.operations(period, "overview", signal)');
+    expect(hydration).toContain("operationsDetailStartDelayMs = 0");
+    expect(hydration).not.toContain("requestIdleCallback");
+  });
+
+  it("invalidates the full detail snapshot before loading a new period overview", () => {
+    const app = readFileSync(
+      new URL("../../../../apps/frontend/src/App.tsx", import.meta.url),
+      "utf8",
+    );
+
+    expect(app).toContain("operationsDetailLoadedRef.current = false;");
+    expect(app).toContain("costsLoadedRef.current = false;");
+    expect(app).toContain("setOperationsPeriod({ preset, range });");
   });
 
   it("treats completed as a Run status in the Runs view, not a work stage", () => {
@@ -49,6 +147,17 @@ describe("overview period filter", () => {
     expect(source).toContain("macroWorkStage(row, data.tasks) === statusFilter");
   });
 
+  it("resets the real List navigation callback on re-entry without changing Kanban routing", () => {
+    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+
+    expect(workListTypeOnViewChange("work-list")).toBe("all");
+    expect(workListTypeOnViewChange("work-kanban")).toBeNull();
+    expect(source).toContain("const nextWorkListType = workListTypeOnViewChange(nextView)");
+    expect(source).toContain("onWorkListTypeChange?.(nextWorkListType)");
+    expect(source).toContain('if (view === "work-kanban") onBoardFiltersChange?.(filters)');
+    expect(source).toContain("else onWorkListFiltersChange?.(filters)");
+  });
+
   it("scopes task and macro metrics to the active overview entity kind", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
 
@@ -58,6 +167,16 @@ describe("overview period filter", () => {
     expect(source).toContain("run.prd_id !== null && macroIds.has(run.prd_id)");
   });
 
+  it("keeps the overview projection run-free while details load separately", () => {
+    const source = readFileSync(
+      new URL("../server/build-operations-projection.ts", import.meta.url),
+      "utf8",
+    );
+
+    expect(source).toContain("readScopedRuns(filesystem, layout, normalizedFilter)");
+    expect(source).toContain("runs: options.overviewOnly ? [] : recentRunsFirst(runs)");
+  });
+
   it("keeps duration execution-only but lets global usage cards span all filtered phases", () => {
     const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
 
@@ -66,4 +185,22 @@ describe("overview period filter", () => {
     expect(source).toContain("overviewMetrics?.tokens ?? allPhaseMetrics.tokens");
     expect(source).toContain("const selectedMetricRuns = runsForOverviewView");
   });
+
+  it("propagates period activity from Tasks and SPECs to their parent macros", () => {
+    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+
+    expect(source).toContain("const periodMacros = macrosWithPeriodActivity");
+    expect(source).toContain("periodMacros.specs.includes(row)");
+    expect(source).toContain("periodMacros.prds.includes(row)");
+  });
+
+  it("uses the creation-only summary population for reports and their exported rows", () => {
+    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+
+    expect(source).toContain(
+      "const summaryPopulation = periodSummaryPopulation(data, matchesSelectedDate);",
+    );
+    expect(source).toContain("aggregatePeriodSummary(\n        summaryPopulation,");
+    expect(source).toContain("data={summaryPopulation}");
+  });
 });

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

@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const source = readFileSync(new URL("./OperationsOverview.tsx", import.meta.url), "utf8");
+
+describe("OperationsOverview status cards", () => {
+  it("opens a filtered dialog for Tasks, SPECs, and PRDs", () => {
+    expect(source).toContain('return item.key !== "unclassified" ?');
+    expect(source).toContain('overviewView === "tasks" ? "task"');
+    expect(source).toContain('kind={overviewView === "tasks" ? "task"');
+    expect(source).not.toContain("macroWorkStage(macro, tasks) === selectedStatus");
+  });
+
+  it("uses selected-type labels, closes before document navigation, and paginates", () => {
+    expect(source).toContain("onOpenDocument(item.kind, item.id)");
+    expect(source).toContain("setSelectedStatus(null);");
+    expect(source).toContain('"Status das tarefas"');
+    expect(source).toContain('"Status das SPECs"');
+    expect(source).toContain('"Status dos PRDs"');
+    expect(source).toContain("const total = page?.total ?? items.length;");
+    expect(source).toContain("aria-label={`${label} — ${total} ${taskLabel}`}");
+    expect(source).toContain("onLoadMore(items.length)");
+    expect(source).toContain('aria-busy="true"');
+    expect(source).toContain('role="alert"');
+    expect(source).toContain("Nenhum${kind === \"task\" ? \"a\" : \"\"}");
+  });
+});