@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/metric-accessibility.test.ts

@@ -0,0 +1,17 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const overview = readFileSync(new URL("./OperationsOverview.helpers.tsx", import.meta.url), "utf8");
+const periods = readFileSync(new URL("./PeriodSummaryTable.tsx", import.meta.url), "utf8");
+
+describe("metric accessibility names", () => {
+  it("binds every KPI title to its displayed value and hint", () => {
+    expect(overview).toContain("aria-label={`${label}: ${value}. ${hint}`}");
+  });
+
+  it("keeps the existing token footer display and reuses it in the total name", () => {
+    expect(periods).toContain("const totalTokensDisplay = formatCompactNumber(total.tokens);");
+    expect(periods).toContain("aria-label={`${totalLabel} — Tokens: ${totalTokensDisplay}`}");
+    expect(periods).toMatch(/<output[^>]+>[\s\S]*?\{totalTokensDisplay\}[\s\S]*?<\/output>/);
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+  dateRangeForPreset,
+  initialTaskDateRange,
+  isDateInOperationPreset,
+  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", () => {
+    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" });
+  });
+
+  it.each([
+    ["today", "2026-07-14", "2026-07-14"],
+    ["yesterday", "2026-07-13", "2026-07-13"],
+    ["this-week", "2026-07-13", "2026-07-14"],
+    ["last-week", "2026-07-06", "2026-07-12"],
+    ["this-month", "2026-07-01", "2026-07-14"],
+    ["last-month", "2026-06-01", "2026-06-30"],
+    ["last-3-months", "2026-04-14", "2026-07-14"],
+    ["last-6-months", "2026-01-14", "2026-07-14"],
+    ["this-year", "2026-01-01", "2026-07-14"],
+    ["last-year", "2025-01-01", "2025-12-31"],
+  ] as const)("builds the %s preset", (preset, start, end) => {
+    expect(dateRangeForPreset(preset, today)).toEqual({ start, end });
+  });
+
+  it("uses inclusive date limits", () => {
+    const range = { start: "2026-07-10", end: "2026-07-14" };
+    expect(isTaskCreatedInRange("2026-07-10T12:00:00.000Z", range)).toBe(true);
+    expect(isTaskCreatedInRange("2026-07-14T12:00:00.000Z", range)).toBe(true);
+    expect(isTaskCreatedInRange("2026-07-09T12:00:00.000Z", range)).toBe(false);
+  });
+
+  it("uses America/Sao_Paulo at the 03:00Z daily boundary", () => {
+    const fifteenth = { start: "2026-07-15", end: "2026-07-15" };
+    expect(isTaskCreatedInRange("2026-07-16T02:59:59.000Z", fifteenth)).toBe(true);
+    expect(isTaskCreatedInRange("2026-07-16T03:00:00.000Z", fifteenth)).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);
+    expect(isDateInOperationPreset("2024-01-01T00:00:00.000Z", "this-month", july)).toBe(false);
+    expect(isDateInOperationPreset("2026-08-01T02:30:00.000Z", "this-month", july)).toBe(true);
+  });
+});

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

@@ -0,0 +1,135 @@
+export type OperationDatePreset =
+  | "all"
+  | "custom"
+  | "today"
+  | "yesterday"
+  | "this-week"
+  | "last-week"
+  | "this-month"
+  | "last-month"
+  | "last-3-months"
+  | "last-6-months"
+  | "this-year"
+  | "last-year";
+
+export interface OperationDateRange {
+  start: string;
+  end: string;
+}
+
+export function initialTaskDateRange(
+  tasks: readonly { created_at: string }[],
+  today = new Date(),
+): OperationDateRange {
+  const earliestTimestamp = tasks.reduce(
+    (earliest, task) => Math.min(earliest, Date.parse(task.created_at)),
+    Number.POSITIVE_INFINITY,
+  );
+  const start = Number.isFinite(earliestTimestamp) ? new Date(earliestTimestamp) : today;
+  start.setUTCDate(start.getUTCDate() - 1);
+  return { start: toDateInputValue(start), end: toDateInputValue(today) };
+}
+
+export function dateRangeForPreset(
+  preset: Exclude<OperationDatePreset, "all" | "custom">,
+  today = new Date(),
+): OperationDateRange {
+  const end = atLocalNoon(today);
+  let start = atLocalNoon(today);
+
+  if (preset === "yesterday") {
+    start = addDays(end, -1);
+    return range(start, start);
+  }
+  if (preset === "this-week") {
+    return range(addDays(end, -mondayIndex(end)), end);
+  }
+  if (preset === "last-week") {
+    const thisMonday = addDays(end, -mondayIndex(end));
+    return range(addDays(thisMonday, -7), addDays(thisMonday, -1));
+  }
+  if (preset === "this-month") {
+    return range(new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), 1, 12)), end);
+  }
+  if (preset === "last-month") {
+    return range(
+      new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth() - 1, 1, 12)),
+      new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), 0, 12)),
+    );
+  }
+  if (preset === "last-3-months") return range(addMonthsClamped(end, -3), end);
+  if (preset === "last-6-months") return range(addMonthsClamped(end, -6), end);
+  if (preset === "this-year") return range(new Date(Date.UTC(end.getUTCFullYear(), 0, 1, 12)), end);
+  if (preset === "last-year") {
+    return range(
+      new Date(Date.UTC(end.getUTCFullYear() - 1, 0, 1, 12)),
+      new Date(Date.UTC(end.getUTCFullYear() - 1, 11, 31, 12)),
+    );
+  }
+  return range(end, end);
+}
+
+export function isTaskCreatedInRange(
+  createdAt: string | null | undefined,
+  dateRange: OperationDateRange,
+  updatedAt?: string | null,
+): boolean {
+  return isDateInRange(createdAt ?? updatedAt, dateRange);
+}
+
+export function isDateInRange(
+  value: string | null | undefined,
+  dateRange: OperationDateRange,
+): boolean {
+  if (value == null) return false;
+  const date = saoPauloPeriodKey(value, "day");
+  if (date === null) return false;
+  return date >= dateRange.start && date <= dateRange.end;
+}
+
+/** All Time deliberately has no local date bound. */
+export function isDateInOperationPreset(
+  value: string | null | undefined,
+  preset: OperationDatePreset,
+  dateRange: OperationDateRange,
+): boolean {
+  return preset === "all" || isDateInRange(value, dateRange);
+}
+
+function range(start: Date, end: Date): OperationDateRange {
+  return { start: toDateInputValue(start), end: toDateInputValue(end) };
+}
+
+function atLocalNoon(value: Date): Date {
+  const key = saoPauloPeriodKey(value.toISOString(), "day");
+  if (key === null) throw new RangeError("Invalid Operations date anchor");
+  return new Date(`${key}T12:00:00.000Z`);
+}
+
+function addDays(value: Date, amount: number): Date {
+  const result = new Date(value);
+  result.setUTCDate(result.getUTCDate() + amount);
+  return result;
+}
+
+function addMonthsClamped(value: Date, amount: number): Date {
+  const day = value.getUTCDate();
+  const result = new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth() + amount, 1, 12));
+  const lastDay = new Date(
+    Date.UTC(result.getUTCFullYear(), result.getUTCMonth() + 1, 0, 12),
+  ).getUTCDate();
+  result.setUTCDate(Math.min(day, lastDay));
+  return result;
+}
+
+function mondayIndex(value: Date): number {
+  return (value.getUTCDay() + 6) % 7;
+}
+
+function toDateInputValue(value: Date): string {
+  const key = saoPauloPeriodKey(value.toISOString(), "day");
+  if (key === null) throw new RangeError("Invalid Operations date value");
+  return key;
+}
+
+import { saoPauloPeriodKey } from "../contracts.js";

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { formatOperationDuration, operationalDurationMs } from "./operation-duration.js";
+
+describe("formatOperationDuration", () => {
+  it("preserves unavailable and observed zero as different states", () => {
+    expect(formatOperationDuration(null, "pt-BR")).toBe("Indisponível");
+    expect(formatOperationDuration(0, "pt-BR")).toBe("0 seg");
+  });
+
+  it("uses lifecycle interval only as operational list time", () => {
+    expect(
+      operationalDurationMs({
+        duration_ms: null,
+        started_at: "2026-07-28T10:00:00Z",
+        finished_at: "2026-07-28T11:00:00Z",
+      }),
+    ).toBe(3_600_000);
+  });
+});

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

@@ -0,0 +1,27 @@
+import { formatDurationMs } from "@zaip-ai/dashboard-ui";
+import type { OperationsLocale } from "./status-labels.js";
+
+export interface OperationalTiming {
+  duration_ms: number | null;
+  source_duration_ms?: number | null;
+  started_at: string;
+  finished_at: string | null;
+}
+
+export function formatOperationDuration(value: number | null, locale: OperationsLocale): string {
+  if (value === null) return locale === "pt-BR" ? "Indisponível" : "Unavailable";
+  if (value === 0) return locale === "pt-BR" ? "0 seg" : "0 sec";
+  return formatDurationMs(value, locale);
+}
+
+/** 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;
+  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;
+}

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

@@ -0,0 +1,154 @@
+.operations-toolbar {
+  flex-wrap: wrap;
+  align-items: flex-end;
+}
+
+.operations-toolbar nav {
+  flex: 1 1 620px;
+}
+
+.operations-toolbar-filters {
+  display: grid;
+  grid-template-columns: minmax(210px, 1.35fr) repeat(2, minmax(128px, 0.8fr)) minmax(155px, 1fr);
+  gap: 8px;
+  align-items: end;
+  margin-left: auto;
+}
+
+.dashboard-global-controls {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 18px;
+  margin: 22px 0 14px;
+  scroll-margin-top: 82px;
+}
+
+.dashboard-global-controls .dashboard-capability-nav {
+  flex: 0 0 auto;
+  margin: 0;
+}
+
+.dashboard-global-filters {
+  width: min(760px, 100%);
+  min-width: 0;
+  flex: 0 1 760px;
+  margin-left: auto;
+}
+
+.operations-toolbar-field {
+  display: grid;
+  min-width: 0;
+  gap: 4px;
+}
+
+.operations-toolbar-field > span {
+  color: #64748b;
+  font-size: 0.51rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.operations-search-control {
+  position: relative;
+  min-width: 0;
+}
+
+.dashboard-global-controls .operations-search-control input {
+  padding-right: 38px;
+}
+
+.dashboard-global-controls .operations-search-clear {
+  position: absolute;
+  top: 50%;
+  right: 7px;
+  display: grid;
+  width: 26px;
+  height: 26px;
+  padding: 0;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: #71829a;
+  cursor: pointer;
+  place-items: center;
+  transform: translateY(-50%);
+}
+
+.dashboard-global-controls .operations-search-clear:hover {
+  background: rgba(125, 211, 252, 0.1);
+  color: #bae6fd;
+}
+
+.dashboard-global-controls .operations-search-clear:focus-visible {
+  outline: 2px solid #38bdf8;
+  outline-offset: 1px;
+}
+
+.operations-search-clear svg {
+  width: 16px;
+  height: 16px;
+  stroke: currentColor;
+  stroke-linecap: round;
+  stroke-width: 1.8;
+}
+
+.operations-toolbar .operations-toolbar-field input,
+.operations-toolbar .operations-toolbar-field select,
+.dashboard-global-controls .operations-toolbar-field input,
+.dashboard-global-controls .operations-toolbar-field select {
+  width: 100%;
+  min-width: 0;
+  min-height: 36px;
+  border: 1px solid var(--line-strong);
+  border-radius: 10px;
+  padding: 6px 9px;
+  background: rgba(10, 14, 23, 0.96);
+  color: var(--text);
+  font-size: 0.76rem;
+}
+
+.operations-toolbar .operations-date-field input,
+.dashboard-global-controls .operations-date-field input {
+  color-scheme: dark;
+}
+
+.operations-toolbar .operations-period-field select,
+.dashboard-global-controls .operations-period-field select {
+  padding-right: 30px;
+}
+
+@media (max-width: 760px) {
+  .dashboard-global-controls {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .dashboard-global-controls .dashboard-capability-nav,
+  .dashboard-global-filters {
+    width: 100%;
+    min-width: 0;
+  }
+
+  .operations-toolbar-filters {
+    width: 100%;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .operations-search-field,
+  .operations-period-field {
+    grid-column: 1 / -1;
+  }
+}
+
+@media (max-width: 420px) {
+  .operations-toolbar-filters {
+    grid-template-columns: 1fr;
+  }
+
+  .operations-search-field,
+  .operations-period-field {
+    grid-column: auto;
+  }
+}

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

@@ -0,0 +1,187 @@
+.operations-global-filters {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(160px, 1fr));
+  align-items: end;
+  gap: 16px 12px;
+  padding: 6px;
+}
+.dashboard-header-filter-popup:has(.operations-global-filters) {
+  inset: 76px 24px auto auto;
+  width: min(940px, calc(100vw - 48px));
+  padding: 20px;
+  border-color: rgba(125, 211, 252, 0.16);
+  border-radius: 20px;
+  background:
+    radial-gradient(circle at 90% 0%, rgba(14, 165, 233, 0.09), transparent 34%),
+    rgba(8, 13, 24, 0.985);
+  box-shadow: 0 26px 70px rgba(0, 0, 0, 0.52);
+}
+.operations-filter-heading {
+  display: flex;
+  grid-column: 1 / -1;
+  align-items: center;
+  justify-content: space-between;
+  gap: 18px;
+  padding: 2px 2px 12px;
+  border-bottom: 1px solid rgba(148, 163, 184, 0.12);
+}
+.operations-filter-heading > div {
+  display: grid;
+  gap: 4px;
+}
+.operations-filter-heading strong {
+  color: #e5f2ff;
+  font-size: 1rem;
+}
+.operations-filter-heading small {
+  color: #71829a;
+  font-size: 0.68rem;
+}
+.operations-filter-status {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: #7dd3fc;
+  font-size: 0.68rem;
+}
+.operations-filter-status i {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: #38bdf8;
+  box-shadow: 0 0 0 5px rgba(56, 189, 248, 0.12);
+  animation: operations-filter-pulse 900ms ease-in-out infinite alternate;
+}
+.operations-global-filters label {
+  display: grid;
+  gap: 7px;
+}
+.operations-global-filters label > span {
+  color: var(--muted);
+  font-size: 0.67rem;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+.operations-global-filters input,
+.operations-global-filters select {
+  min-width: 0;
+  min-height: 42px;
+  border: 1px solid var(--line-strong);
+  border-radius: 13px;
+  padding: 0 14px;
+  background: rgba(8, 14, 25, 0.9);
+  color: var(--text);
+  outline: none;
+  transition:
+    border-color 140ms ease,
+    box-shadow 140ms ease,
+    background 140ms ease;
+}
+.operations-global-filters input:hover,
+.operations-global-filters select:hover {
+  border-color: rgba(125, 211, 252, 0.28);
+}
+.operations-global-filters input:focus,
+.operations-global-filters select:focus {
+  border-color: rgba(56, 189, 248, 0.7);
+  background: rgba(10, 20, 35, 0.98);
+  box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.1);
+}
+.operations-filter-search {
+  grid-column: span 2;
+}
+.operations-global-filters .operations-date-field input {
+  color-scheme: dark;
+}
+.dashboard-header .operations-clear-filters {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 9px;
+  min-height: 42px;
+  border-color: rgba(125, 211, 252, 0.22);
+  background: rgba(14, 116, 144, 0.1);
+  color: #bae6fd;
+}
+@media (max-width: 820px) {
+  .operations-global-filters {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+.operations-reset-icon {
+  width: 16px;
+  height: 16px;
+  stroke: currentColor;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-width: 2;
+}
+@keyframes operations-filter-pulse {
+  to {
+    opacity: 0.42;
+    transform: scale(0.78);
+  }
+}
+.operations-loading-line {
+  position: fixed;
+  top: 63px;
+  right: 0;
+  left: 0;
+  z-index: 59;
+  height: 2px;
+  overflow: hidden;
+  background: rgba(56, 189, 248, 0.08);
+}
+.operations-loading-line::after {
+  position: absolute;
+  width: 32%;
+  height: 100%;
+  background: linear-gradient(90deg, transparent, #38bdf8, transparent);
+  content: "";
+  animation: operations-loading-slide 850ms ease-in-out infinite;
+}
+@keyframes operations-loading-slide {
+  from {
+    transform: translateX(-110%);
+  }
+  to {
+    transform: translateX(420%);
+  }
+}
+.operations-filtered {
+  transition: opacity 140ms ease;
+}
+.operations-filtered.is-loading {
+  opacity: 1;
+  pointer-events: auto;
+}
+.operations-loading-status {
+  position: fixed;
+  z-index: 75;
+  right: 18px;
+  bottom: 18px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  border: 1px solid rgba(56, 189, 248, 0.35);
+  border-radius: 14px;
+  padding: 12px 14px;
+  background: rgba(15, 23, 42, 0.96);
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.28);
+  color: #dbeafe;
+  font-size: 0.86rem;
+}
+.operations-loading-status::before {
+  content: "";
+  width: 18px;
+  height: 18px;
+  border: 3px solid #334155;
+  border-radius: 50%;
+  border-top-color: #38bdf8;
+  animation: operations-loading-spin 900ms linear infinite;
+}
+@keyframes operations-loading-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}

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

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { workStages } from "./work-board-model.js";
+
+describe("operations board layout", () => {
+  it("declares one grid column for every work stage", () => {
+    const css = readFileSync(new URL("./operations.css", import.meta.url), "utf8");
+    const declaredColumns = Number(
+      css.match(/\.operations-board\s*\{[^}]*grid-template-columns:\s*repeat\((\d+)/s)?.[1],
+    );
+
+    expect(workStages.at(-1)).toBe("failed");
+    expect(declaredColumns).toBe(workStages.length);
+  });
+});

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

@@ -0,0 +1,69 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+describe("overview period filter", () => {
+  it("passes the period-filtered 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).not.toContain("runs={data.runs}");
+  });
+
+  it("derives all monetary and duration KPIs from the period-filtered Runs", () => {
+    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 ??");
+    expect(source).toContain("effortMetrics.durationMs");
+    expect(source).toContain("overviewMetrics?.tokens ?? allPhaseMetrics.tokens");
+    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", () => {
+    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("if (!isCurrentRequest()) return;");
+  });
+
+  it("treats completed as a Run status in the Runs view, not a work stage", () => {
+    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
+
+    expect(source).toContain('(view === "work-kanban" || view === "work-list")');
+    expect(source).toContain("row.status === statusFilter");
+    expect(source).toContain("macroWorkStage(row, data.tasks) === statusFilter");
+  });
+
+  it("scopes task and macro metrics to the active overview entity kind", () => {
+    const source = readFileSync(new URL("OperationsOverview.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)");
+  });
+
+  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");
+
+    expect(source).toContain("const executionMetrics = executionMetricTotals(runs)");
+    expect(source).toContain("const allPhaseMetrics = allPhaseMetricTotals(runs)");
+    expect(source).toContain("overviewMetrics?.tokens ?? allPhaseMetrics.tokens");
+    expect(source).toContain("const selectedMetricRuns = runsForOverviewView");
+  });
+});