@zaip-ai/cli 1.3.8 → 1.4.1

package/templates/.agents/dashboard/apps/frontend/src/project-settings-model.ts

@@ -9,7 +9,8 @@ export const stackComponentDefinitions = [
   { id: "auth_storage", defaultName: "Supabase Auth + Storage", scope: "backend" },
   { id: "cache_messaging", defaultName: "Redis", scope: "backend" },
   { id: "async_queue", defaultName: "BullMQ", scope: "backend" },
-  { id: "backend_infrastructure", defaultName: "Hostinger VPS", scope: "backend" },
+  { id: "backend_infrastructure", defaultName: "Terraform", scope: "backend" },
+  { id: "backend_hosting", defaultName: "Hostinger VPS", scope: "backend" },
   { id: "web_framework", defaultName: "React", scope: "frontend" },
   { id: "web_language", defaultName: "TypeScript", scope: "frontend" },
   { id: "web_build", defaultName: "Vite", scope: "frontend" },
@@ -19,6 +20,14 @@ export const stackComponentDefinitions = [
   { id: "site_islands", defaultName: "React Islands", scope: "site" },
   { id: "site_build", defaultName: "Vite", scope: "site" },
   { id: "site_hosting", defaultName: "Cloudflare Pages", scope: "site" },
+  { id: "prometheus", defaultName: "Prometheus", scope: "observability" },
+  { id: "grafana", defaultName: "Grafana", scope: "observability" },
+  { id: "uptime_kuma", defaultName: "Uptime Kuma", scope: "observability" },
+  { id: "cadvisor", defaultName: "cAdvisor", scope: "observability" },
+  { id: "node_exporter", defaultName: "node-exporter", scope: "observability" },
+  { id: "redis_exporter", defaultName: "Redis Exporter", scope: "observability" },
+  { id: "k6", defaultName: "k6", scope: "testing" },
+  { id: "autocannon", defaultName: "autocannon", scope: "testing" },
 ] as const;
 
 export type StackComponentId = (typeof stackComponentDefinitions)[number]["id"];
@@ -107,13 +116,16 @@ export function buildProjectSettingsPayload(
       },
     ]),
   ) as StackComponentsDraft;
+  const existingComponents = isRecord(config.stack.overrides.components)
+    ? config.stack.overrides.components
+    : {};
   return {
     ...config,
     stack: {
       ...config.stack,
       overrides: {
         ...otherOverrides,
-        components: normalized,
+        components: { ...existingComponents, ...normalized },
         languages: {
           frontend: componentNames(normalized, "frontend"),
           backend: componentNames(normalized, "backend"),

package/templates/.agents/dashboard/apps/frontend/src/project-settings.test.ts

@@ -70,6 +70,7 @@ describe("project settings form mapping", () => {
           "Supabase Auth + Storage",
           "Redis",
           "BullMQ",
+          "Terraform",
           "Hostinger VPS",
         ],
         site: ["Astro", "TypeScript", "React Islands", "Vite", "Cloudflare Pages"],
@@ -98,6 +99,40 @@ describe("project settings form mapping", () => {
     ).toThrow("deve ser exata");
   });
 
+  it("keeps observability and on-demand testing tools editable with pinned-or-empty versions", () => {
+    const configured = {
+      ...config,
+      stack: {
+        ...config.stack,
+        overrides: {
+          ...config.stack.overrides,
+          components: { future_tool: { enabled: true } },
+        },
+      },
+    } satisfies ProjectConfigSettings;
+    const draft = projectSettingsDraft(configured);
+    const components = {
+      ...draft.components,
+      prometheus: { name: "Prometheus", version: "3.6.0", reference: "docker:prom/prometheus" },
+      grafana: { name: "Grafana", version: "", reference: "docker:grafana/grafana" },
+      k6: { name: "k6", version: "1.1.0", reference: "docker:grafana/k6" },
+      autocannon: { name: "autocannon", version: "", reference: "npm:autocannon" },
+    };
+
+    const payload = buildProjectSettingsPayload(configured, components, draft.otherOverrides);
+
+    expect(payload.stack.overrides).toMatchObject({
+      components: {
+        prometheus: components.prometheus,
+        grafana: components.grafana,
+        uptime_kuma: { name: "Uptime Kuma", version: "", reference: "" },
+        k6: components.k6,
+        autocannon: components.autocannon,
+        future_tool: { enabled: true },
+      },
+    });
+  });
+
   it("keeps execution and assurance settings in the save payload", () => {
     const configured: ProjectConfigSettings = {
       ...config,

package/templates/.agents/dashboard/apps/frontend/src/snapshot-coherence.test.ts

@@ -2,7 +2,20 @@ import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import { isCurrentDashboardRequest, mergeBoardPages, needsAtomicCostSnapshot } from "./App.js";
 import { loadAtomicCostSnapshot } from "./snapshot-coherence.js";
-import { projectionRefreshDebounceMs, shouldRefreshVisibleProjection } from "./use-app-effects.js";
+import {
+  isCommittedSnapshotRevision,
+  projectionRefreshDebounceMs,
+  settleSnapshotRevisionRefresh,
+  shouldPollSnapshotReady,
+  shouldRefreshForSnapshotRevision,
+  shouldRefreshVisibleProjection,
+  snapshotReadyPollAttempts,
+  snapshotReadyPollExhaustedMessage,
+  snapshotRevisionHiddenFailurePollMs,
+  snapshotRevisionHiddenPollMs,
+  snapshotRevisionPollDelay,
+  snapshotRevisionVisiblePollMs,
+} from "./use-app-effects.js";
 
 describe("atomic Cost snapshot loading", () => {
   it("keeps Operations, Cost, and cards on one source generation while the source moves", async () => {
@@ -82,7 +95,7 @@ describe("atomic Cost snapshot loading", () => {
     expect(retry).not.toContain("loadCosts");
   });
 
-  it("does not prefetch or poll a newer Operations snapshot in the background", () => {
+  it("does not prefetch a newer Operations snapshot in the background", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     const effects = readFileSync(new URL("./use-app-effects.ts", import.meta.url), "utf8");
     const costLoaders = readFileSync(new URL("./use-app-cost-loaders.ts", import.meta.url), "utf8");
@@ -135,6 +148,69 @@ describe("atomic Cost snapshot loading", () => {
     expect(effects).toContain("void refresh(false, false, true)");
   });
 
+  it("polls ready only while a startup snapshot reports updating", () => {
+    expect(shouldPollSnapshotReady(true, 0)).toBe(true);
+    expect(shouldPollSnapshotReady(true, snapshotReadyPollAttempts - 1)).toBe(true);
+    expect(shouldPollSnapshotReady(true, snapshotReadyPollAttempts)).toBe(false);
+    expect(shouldPollSnapshotReady(false, 0)).toBe(false);
+    expect(snapshotReadyPollExhaustedMessage).toContain("desatualizados");
+    const effects = readFileSync(new URL("./use-app-effects.ts", import.meta.url), "utf8");
+    expect(effects).toContain("const ready = await api.ready()");
+    expect(effects).toContain("await refresh(false, false, false, true)");
+    expect(effects).not.toContain("refresh(false, true");
+    expect(effects).toContain("setSnapshotUpdating(false);");
+    expect(effects).toContain("setError(snapshotReadyPollExhaustedMessage)");
+  });
+
+  it("observes committed snapshot revisions from an open tab with GET-only refreshes", () => {
+    expect(snapshotRevisionPollDelay("visible", 0)).toBe(snapshotRevisionVisiblePollMs);
+    expect(snapshotRevisionPollDelay("hidden", 0)).toBe(snapshotRevisionHiddenPollMs);
+    expect(snapshotRevisionPollDelay("hidden", 1)).toBe(snapshotRevisionHiddenFailurePollMs);
+    const committedHash = "40fb07a77e3f";
+    const nextCommittedHash = "1c83d5ea7142";
+    expect(shouldRefreshForSnapshotRevision(null, committedHash)).toBe(false);
+    expect(shouldRefreshForSnapshotRevision(committedHash, undefined)).toBe(false);
+    expect(shouldRefreshForSnapshotRevision(committedHash, committedHash)).toBe(false);
+    // `updating` only means a later generation is being prepared. The hash
+    // still identifies the already committed SQLite generation and can make
+    // an open tab reload when it differs from the last applied one.
+    expect(isCommittedSnapshotRevision("updating", nextCommittedHash)).toBe(true);
+    expect(shouldRefreshForSnapshotRevision(committedHash, nextCommittedHash)).toBe(true);
+    expect(isCommittedSnapshotRevision("current", undefined)).toBe(false);
+    expect(isCommittedSnapshotRevision("current", nextCommittedHash)).toBe(true);
+
+    const afterFailedReload = settleSnapshotRevisionRefresh({
+      observedRevision: "revision-1",
+      pendingRevision: "revision-2",
+      requestedRevision: "revision-2",
+      succeeded: false,
+    });
+    expect(afterFailedReload).toEqual({
+      observedRevision: "revision-1",
+      pendingRevision: "revision-2",
+    });
+    expect(
+      settleSnapshotRevisionRefresh({
+        ...afterFailedReload,
+        requestedRevision: "revision-2",
+        succeeded: true,
+      }),
+    ).toEqual({ observedRevision: "revision-2", pendingRevision: null });
+
+    const effects = readFileSync(new URL("./use-app-effects.ts", import.meta.url), "utf8");
+    expect(effects).toContain("const observedSnapshotRevision = useRef<string | null>(null)");
+    expect(effects).toContain("pendingSnapshotRevisionRefresh");
+    expect(effects).toContain(
+      "isCommittedSnapshotRevision(ready.snapshot_state, ready.snapshot_revision)",
+    );
+    expect(effects).toContain("settleSnapshotRevisionRefresh({");
+    expect(effects).toContain(
+      "snapshotRevisionPollDelay(document.visibilityState, consecutiveFailures)",
+    );
+    expect(effects).toContain("void refresh(false, false, false, true)");
+    expect(effects).not.toContain("refresh(false, false, true, true)");
+  });
+
   it("does not reconcile open work automatically", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     expect(app).not.toContain("startupReconciliation");

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.test.ts

@@ -119,6 +119,34 @@ describe("daily Cost Monitor continuous pagination", () => {
   });
 });
 
+describe("SQLite Cost group duration adapter", () => {
+  it("prefers total_duration over a synthesized duration_known zero and uses zero only when absent", async () => {
+    const api = {
+      sqliteViewPage: async () => ({
+        offset: 0,
+        limit: 10,
+        total_count: 2,
+        has_more: false,
+        rows: [
+          { key: "gpt-5.6-sol", total_duration: 285_480_000, duration_known: 0 },
+          { key: "unavailable", total_duration: null, duration_known: undefined },
+        ],
+      }),
+    };
+    const page = await loadSqliteCostGroupPage(api as never, {
+      view: "models",
+      offset: 0,
+      limit: 10,
+      filters: {} as never,
+    });
+
+    expect(page.rows).toMatchObject([
+      { key: "gpt-5.6-sol", duration_ms: 285_480_000, duration: { known_sum: 285_480_000 } },
+      { key: "unavailable", duration_ms: null, duration: { known_sum: 0 } },
+    ]);
+  });
+});
+
 describe("adaptSqliteCostRun", () => {
   it("renders a sparse API invocation row without throwing and marks missing multipliers unavailable", () => {
     const run = adaptSqliteCostRun({

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.ts

@@ -40,7 +40,9 @@ function costGroupQueryOptions(request: CostGroupLoadRequest, offset: number, li
 function adaptSqliteCostGroup(row: Record<string, unknown>) {
   const duration = costGroupDuration(row);
   const durationUnknown = Number(row.duration_unknown ?? (duration === null ? 1 : 0));
-  const durationKnown = nullableSqlNumber(row.duration_known) ?? duration ?? 0;
+  // Model rows may expose only `total_duration`. Prefer it over a legacy
+  // synthesized zero in `duration_known` so the table and export agree.
+  const durationKnown = duration ?? nullableSqlNumber(row.duration_known) ?? 0;
   return {
     key: String(row.key ?? row.period_key ?? "total"),
     label: String(row.label ?? row.key ?? row.period_key ?? ""),
@@ -49,10 +51,11 @@ function adaptSqliteCostGroup(row: Record<string, unknown>) {
     job: typeof row.job === "string" ? row.job : null,
     run_count: Number(row.total_run_count ?? row.invocation_count ?? 0),
     task_count: nullableSqlNumber(row.task_count),
-    prd_count: Number(row.prd_count ?? 0),
-    spec_count: Number(row.spec_count ?? 0),
-    evidence_count: Number(row.evidence_count ?? 0),
-    test_count: Number(row.validation_count ?? 0),
+    conversation_count: Number(row.conversation_count ?? 0),
+    prd_count: nullableSqlNumber(row.prd_count),
+    spec_count: nullableSqlNumber(row.spec_count),
+    evidence_count: nullableSqlNumber(row.evidence_count),
+    test_count: nullableSqlNumber(row.validation_count),
     event_count: Number(row.source_event_count ?? 0),
     total_tokens: nullableSqlNumber(row.total_tokens),
     estimated_usd: nullableSqlNumber(row.total_cost_usd),

package/templates/.agents/dashboard/apps/frontend/src/use-app-effects.ts

@@ -17,6 +17,68 @@ import {
 } from "./operations-detail-hydration.js";
 
 export const projectionRefreshDebounceMs = 5_000;
+export const snapshotReadyPollMs = 2_000;
+export const snapshotReadyPollAttempts = 90;
+export const snapshotRevisionVisiblePollMs = 5_000;
+export const snapshotRevisionHiddenPollMs = 10_000;
+export const snapshotRevisionHiddenFailurePollMs = 30_000;
+export const snapshotReadyPollExhaustedMessage =
+  "A atualização do snapshot não foi concluída. Os dados exibidos podem estar desatualizados.";
+
+export function shouldPollSnapshotReady(snapshotUpdating: boolean, attempts: number): boolean {
+  return snapshotUpdating && attempts < snapshotReadyPollAttempts;
+}
+
+export function snapshotRevisionPollDelay(
+  visibilityState: DocumentVisibilityState,
+  consecutiveFailures: number,
+): number {
+  if (visibilityState === "visible") return snapshotRevisionVisiblePollMs;
+  return consecutiveFailures > 0
+    ? snapshotRevisionHiddenFailurePollMs
+    : snapshotRevisionHiddenPollMs;
+}
+
+export function shouldRefreshForSnapshotRevision(
+  previousRevision: string | null,
+  nextRevision: string | undefined,
+): boolean {
+  return (
+    previousRevision !== null &&
+    typeof nextRevision === "string" &&
+    nextRevision.length > 0 &&
+    previousRevision !== nextRevision
+  );
+}
+
+export function isCommittedSnapshotRevision(
+  snapshotState: "current" | "updating" | undefined,
+  snapshotRevision: string | undefined,
+): snapshotRevision is string {
+  return (
+    (snapshotState === "current" || snapshotState === "updating") &&
+    typeof snapshotRevision === "string" &&
+    snapshotRevision.length > 0
+  );
+}
+
+export function settleSnapshotRevisionRefresh({
+  observedRevision,
+  pendingRevision,
+  requestedRevision,
+  succeeded,
+}: {
+  observedRevision: string | null;
+  pendingRevision: string | null;
+  requestedRevision: string;
+  succeeded: boolean;
+}): { observedRevision: string | null; pendingRevision: string | null } {
+  if (!succeeded) return { observedRevision, pendingRevision };
+  return {
+    observedRevision: requestedRevision,
+    pendingRevision: pendingRevision === requestedRevision ? null : pendingRevision,
+  };
+}
 
 export function shouldRefreshVisibleProjection({
   inFlight,
@@ -48,6 +110,8 @@ export function useAppEffects({
   pricing,
   refresh,
   refreshVersion,
+  snapshotUpdating,
+  setSnapshotUpdating,
   setError,
   setFxRate,
   setPathname,
@@ -68,8 +132,11 @@ export function useAppEffects({
     visible?: boolean,
     reconcileOpenWork?: boolean,
     refreshProjection?: boolean,
-  ) => Promise<void>;
+    reloadCostSummary?: boolean,
+  ) => Promise<boolean>;
   refreshVersion: MutableRefObject<number>;
+  snapshotUpdating: boolean;
+  setSnapshotUpdating: Dispatch<SetStateAction<boolean>>;
   setError: Dispatch<SetStateAction<string | null>>;
   setFxRate: Dispatch<SetStateAction<Awaited<ReturnType<DashboardApiClient["fxRate"]>> | null>>;
   setPathname: Dispatch<SetStateAction<string>>;
@@ -77,6 +144,9 @@ export function useAppEffects({
 }) {
   const projectionRefreshInFlight = useRef(false);
   const lastProjectionRefreshAt = useRef(0);
+  const observedSnapshotRevision = useRef<string | null>(null);
+  const snapshotRevisionRefreshInFlight = useRef(false);
+  const pendingSnapshotRevisionRefresh = useRef<string | null>(null);
   useEffect(() => {
     void refresh();
     return () => {
@@ -124,6 +194,115 @@ export function useAppEffects({
     };
   }, [refresh]);
 
+  useEffect(() => {
+    if (!snapshotUpdating) return;
+    let cancelled = false;
+    let attempts = 0;
+    let timeout: number | null = null;
+    const pollReady = async () => {
+      if (cancelled || !shouldPollSnapshotReady(true, attempts)) return;
+      attempts += 1;
+      try {
+        const ready = await api.ready();
+        if (cancelled) return;
+        if (ready.snapshot_state === "current") {
+          setSnapshotUpdating(false);
+          // Promotion produced a new immutable SQLite generation. Reload its
+          // Operations and Cost Monitor summaries by GET; never rebuild or
+          // reconcile as part of the readiness poll.
+          await refresh(false, false, false, true);
+          return;
+        }
+      } catch {
+        // Keep the validated stale seed visible within the bounded poll window.
+      }
+      if (cancelled) return;
+      if (shouldPollSnapshotReady(true, attempts)) {
+        timeout = window.setTimeout(() => void pollReady(), snapshotReadyPollMs);
+        return;
+      }
+      // Stop the progress indicator after the bounded window, while retaining
+      // an explicit visible warning that the stale snapshot remains on screen.
+      setSnapshotUpdating(false);
+      setError(snapshotReadyPollExhaustedMessage);
+    };
+    void pollReady();
+    return () => {
+      cancelled = true;
+      if (timeout !== null) window.clearTimeout(timeout);
+    };
+  }, [api, refresh, setError, setSnapshotUpdating, snapshotUpdating]);
+
+  useEffect(() => {
+    let cancelled = false;
+    let consecutiveFailures = 0;
+    let timeout: number | null = null;
+
+    const refreshChangedRevision = () => {
+      if (cancelled || snapshotRevisionRefreshInFlight.current) return;
+      const requestedRevision = pendingSnapshotRevisionRefresh.current;
+      if (requestedRevision === null) return;
+      snapshotRevisionRefreshInFlight.current = true;
+      // A committed revision is discovered by GET /ready. Its data reload
+      // remains GET-only: it must never start a projection rebuild or
+      // lifecycle reconciliation from a tab that happened to stay open.
+      void refresh(false, false, false, true)
+        .then((succeeded) => {
+          const settled = settleSnapshotRevisionRefresh({
+            observedRevision: observedSnapshotRevision.current,
+            pendingRevision: pendingSnapshotRevisionRefresh.current,
+            requestedRevision,
+            succeeded,
+          });
+          // A failed GET leaves the exact revision pending. The following
+          // passive readiness poll retries it without changing the UI state.
+          observedSnapshotRevision.current = settled.observedRevision;
+          pendingSnapshotRevisionRefresh.current = settled.pendingRevision;
+        })
+        .finally(() => {
+          snapshotRevisionRefreshInFlight.current = false;
+          // A newer committed revision that arrived while this GET was in
+          // flight can run immediately; retrying the same rejected revision
+          // waits for the normal passive polling cadence.
+          if (pendingSnapshotRevisionRefresh.current !== requestedRevision) {
+            refreshChangedRevision();
+          }
+        });
+    };
+
+    const pollRevision = async () => {
+      try {
+        const ready = await api.ready();
+        if (cancelled) return;
+        consecutiveFailures = 0;
+        const previousRevision = observedSnapshotRevision.current;
+        if (isCommittedSnapshotRevision(ready.snapshot_state, ready.snapshot_revision)) {
+          if (previousRevision === null) {
+            observedSnapshotRevision.current = ready.snapshot_revision;
+          }
+          if (shouldRefreshForSnapshotRevision(previousRevision, ready.snapshot_revision)) {
+            pendingSnapshotRevisionRefresh.current = ready.snapshot_revision;
+            refreshChangedRevision();
+          }
+        }
+      } catch {
+        consecutiveFailures += 1;
+      }
+      if (!cancelled) {
+        timeout = window.setTimeout(
+          () => void pollRevision(),
+          snapshotRevisionPollDelay(document.visibilityState, consecutiveFailures),
+        );
+      }
+    };
+
+    void pollRevision();
+    return () => {
+      cancelled = true;
+      if (timeout !== null) window.clearTimeout(timeout);
+    };
+  }, [api, refresh]);
+
   useEffect(() => {
     if (
       !shouldHydrateOperationsDetails(

package/templates/.agents/dashboard/modules/cost-monitor/src/contracts.ts

@@ -135,6 +135,8 @@ export interface CostGroupRow {
   run_count: number;
   /** Null when a paged source does not provide a factual task attribution. */
   task_count: number | null;
+  /** Distinct factual conversation memberships for the displayed model. */
+  conversation_count?: number | null;
   /** Canonical export fields; task_count remains the active-task alias. */
   tasksCreated?: number;
   tasksActive?: number | null;
@@ -143,10 +145,11 @@ export interface CostGroupRow {
   /** Stable ZAIP identity details for the Agent aggregation only. */
   persona?: string | null;
   job?: string | null;
-  prd_count: number;
-  spec_count: number;
-  evidence_count: number;
-  test_count: number;
+  /** Creation-run attribution is unavailable when canonical linkage is absent. */
+  prd_count: number | null;
+  spec_count: number | null;
+  evidence_count: number | null;
+  test_count: number | null;
   event_count: number;
   total_tokens: number | null;
   estimated_usd: number | null;

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostMonitorContent.tsx

@@ -290,16 +290,22 @@ export function CostMonitorContent({
               locale={locale}
               loading={groupPageLoading}
               rows={groups[key]}
-              {...(key === "models" || key === "providers"
-                ? { totals: summaryTotals }
-                : groupPage?.totals === undefined
+              {...(key === "models"
+                ? groupPage?.totals === undefined
                   ? {}
-                  : { totals: groupPage.totals })}
+                  : { totals: groupPage.totals }
+                : key === "providers"
+                  ? { totals: summaryTotals }
+                  : groupPage?.totals === undefined
+                    ? {}
+                    : { totals: groupPage.totals })}
               {...(key === "agents"
                 ? { showDateTime: false, showAgentIdentity: true }
-                : key === "models" || key === "providers"
-                  ? { showDateTime: false, showInvocationTasks: true }
-                  : {})}
+                : key === "models"
+                  ? { showDateTime: false, showModelLifecycleDetails: true }
+                  : key === "providers"
+                    ? { showDateTime: false, showInvocationTasks: true }
+                    : {})}
             />
             {groupPager}
           </>

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostMonitorPage.tsx

@@ -204,6 +204,17 @@ export function CostMonitorPage({
   const [detailLoading, setDetailLoading] = useState(false);
   const [detailError, setDetailError] = useState<string | null>(null);
   const [detailAttempt, setDetailAttempt] = useState(0);
+  // The summary object is replaced only when the host receives a newer
+  // snapshot. Keep this revision separate from tabs and filters so the active
+  // remote table is reloaded without remounting the Cost Monitor surface.
+  const dataRevisionRef = useRef({ data, revision: 0 });
+  if (dataRevisionRef.current.data !== data) {
+    dataRevisionRef.current = {
+      data,
+      revision: dataRevisionRef.current.revision + 1,
+    };
+  }
+  const dataRevision = dataRevisionRef.current.revision;
   const loadDetailRef = useRef(loadDetail);
   loadDetailRef.current = loadDetail;
   const text = costCopy[locale];
@@ -267,6 +278,7 @@ export function CostMonitorPage({
     globalQuery: globalFilters?.query ?? "",
     filters,
     limit: groupPageLimit,
+    revision: dataRevision,
     ...(groupView === null ? {} : { load: loadGroupPage }),
   });
   const displayedGroupPage = groupPageState.page ?? groupPageState.stalePage;
@@ -285,6 +297,7 @@ export function CostMonitorPage({
     range: compactPageRange,
     query: globalFilters?.query,
     filters,
+    revision: dataRevision,
   });
   // Server pagination is safe only when every active Run filter is part of the
   // endpoint contract. Unsupported local text/metadata filters retain the
@@ -309,6 +322,7 @@ export function CostMonitorPage({
     // must not silently add a date range and bypass the fast all-time page.
     range: groupPageRange,
     refresh: lastUpdatedAt,
+    revision: dataRevision,
     load: loadRunPage,
   });
   useEffect(