@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostCharts.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from "vitest";
 import type { CostGroupRow } from "../contracts.js";
-import { costChartsCopy, lastSevenDays, modelsWithObservedCost } from "./CostCharts.js";
+import {
+  chartPhaseMetrics,
+  chartTokenMix,
+  costChartsCopy,
+  lastSevenDays,
+  modelsWithObservedCost,
+} from "./CostCharts.js";
 
 describe("costChartsCopy", () => {
   it("provides complete English chart copy", () => {
@@ -16,10 +22,11 @@ describe("costChartsCopy", () => {
       tokenMix: "Token mix",
       phases: "PHASES",
       totalsByPhase: "Totals by phase",
-      input: "Input",
-      cache: "Cache",
-      output: "Output",
+      inputWithoutCache: "Uncached input",
+      cachedInput: "Cached input",
+      visibleOutput: "Visible output",
       reasoning: "Reasoning",
+      total: "Total (input + output)",
     });
   });
 
@@ -31,33 +38,40 @@ describe("costChartsCopy", () => {
       composition: "COMPOSIÇÃO",
       tokenMix: "Mix de tokens",
       phases: "FASES",
-      input: "Entrada",
-      output: "Saída",
+      inputWithoutCache: "Input sem cache",
+      visibleOutput: "Output visível",
       reasoning: "Raciocínio",
+      total: "Total (input + output)",
     });
   });
 });
 
 describe("lastSevenDays", () => {
-  it("returns today and the six preceding calendar days, filling missing costs with zero", () => {
+  it("uses the last daily buckets from the active interval", () => {
     const rows = [
       { key: "2026-07-10", estimated_brl: 12.5, estimated_usd: 2.3 },
       { key: "2026-07-15", estimated_brl: 8, estimated_usd: 1.5 },
       { key: "2026-07-08", estimated_brl: 99, estimated_usd: 18 },
     ] as CostGroupRow[];
 
-    const result = lastSevenDays(rows, "BRL", new Date(2026, 6, 15, 12));
+    const result = lastSevenDays(rows, "BRL");
 
     expect(result.map((day) => day.key)).toEqual([
-      "2026-07-09",
+      "2026-07-08",
       "2026-07-10",
-      "2026-07-11",
-      "2026-07-12",
-      "2026-07-13",
-      "2026-07-14",
       "2026-07-15",
     ]);
-    expect(result.map((day) => day.value)).toEqual([0, 12.5, 0, 0, 0, 0, 8]);
+    expect(result.map((day) => day.value)).toEqual([99, 12.5, 8]);
+  });
+
+  it("keeps a present daily bucket with unavailable cost distinct from an absent day", () => {
+    const result = lastSevenDays(
+      [{ key: "2026-07-15", estimated_brl: null, estimated_usd: null }] as CostGroupRow[],
+      "BRL",
+    );
+
+    expect(result.at(-1)?.value).toBeNull();
+    expect(result).toHaveLength(1);
   });
 });
 
@@ -70,6 +84,77 @@ describe("modelsWithObservedCost", () => {
     ] as unknown as Parameters<typeof modelsWithObservedCost>[0];
 
     expect(modelsWithObservedCost(rows, "BRL").map((row) => row.key)).toEqual(["sol"]);
-    expect(modelsWithObservedCost(rows, "USD").map((row) => row.key)).toEqual(["sol", "gpt-5"]);
+    expect(modelsWithObservedCost(rows, "USD").map((row) => row.key)).toEqual(["gpt-5", "sol"]);
   });
 });
+
+describe("aggregate-only overview metrics", () => {
+  it("uses inclusive input/output totals for token mix and phases when the Run transport is intentionally empty", () => {
+    const usage = {
+      conversation: metric({ input: 10, cached_input: 1, output: 5, reasoning: 3, total: 15 }, 2),
+      planning: metric({ input: 20, cached_input: 2, output: 10, reasoning: 6, total: 30 }, 3),
+      execution: metric({ input: 30, cached_input: 3, output: 15, reasoning: 9, total: 45 }, 4, 12_000),
+      total: metric({ input: 60, cached_input: 6, output: 30, reasoning: 18, total: 90 }, 9),
+    };
+
+    expect(chartTokenMix([], usage, costChartsCopy("pt-BR")).map(([, value]) => value)).toEqual([
+      54, 6, 12, 18, 90,
+    ]);
+    expect(chartPhaseMetrics("execution", [], usage, "BRL")).toEqual({
+      duration: 12_000,
+      tokens: 45,
+      cost: 4,
+    });
+  });
+
+  it("keeps observed duration zero distinct from unavailable aggregate duration", () => {
+    const base = {
+      conversation: metric({ input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 }, 0),
+      planning: metric({ input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 }, 0),
+      total: metric({ input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 }, 0),
+    };
+    expect(chartPhaseMetrics("execution", [], { ...base, execution: metric({ input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 }, 0, 0) }, "BRL").duration).toBe(0);
+    expect(chartPhaseMetrics("execution", [], { ...base, execution: metric({ input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 }, 0, null) }, "BRL").duration).toBeNull();
+  });
+
+  it("marks an invalid cached or reasoning subset unavailable without changing inclusive totals", () => {
+    const usage = {
+      total: metric({ input: 4, cached_input: 5, output: 6, reasoning: 7, total: 10 }, 1),
+    };
+    expect(chartTokenMix([], usage, costChartsCopy("en-US"))).toEqual([
+      ["Uncached input", null],
+      ["Cached input", null],
+      ["Visible output", null],
+      ["Reasoning", null],
+      ["Total (input + output)", 10],
+    ]);
+  });
+
+  it("preserves canonical output when a partial source total diverges", () => {
+    const usage = {
+      total: metric({ input: 400_000, cached_input: 390_000, output: 30_000, reasoning: 10_000, total: 445_099 }, 1),
+    };
+
+    expect(chartTokenMix([], usage, costChartsCopy("pt-BR")).map(([, value]) => value)).toEqual([
+      10_000,
+      390_000,
+      20_000,
+      10_000,
+      430_000,
+    ]);
+  });
+});
+
+function metric(
+  tokens: { input: number; cached_input: number; output: number; reasoning: number; total: number },
+  brl: number,
+  duration_ms: number | null = null,
+) {
+  return {
+    events: 1,
+    duration_ms,
+    tokens,
+    cost: { usd: brl / 5, brl },
+    coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+  };
+}

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

@@ -1,3 +1,4 @@
+import type { UsageProjection } from "@zaip-ai/dashboard-operations/contracts";
 import { formatCompactNumber, formatCurrency, formatDurationMs } from "@zaip-ai/dashboard-ui";
 import type { CostGroupRow, CostRunRow } from "../contracts.js";
 import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
@@ -8,30 +9,32 @@ export function CostCharts({
   rows,
   daily,
   models,
+  summaryUsage,
   currency,
   locale,
 }: {
   rows: readonly CostRunRow[];
   daily: readonly CostGroupRow[];
   models: readonly CostGroupRow[];
+  /**
+   * The summary route intentionally omits historical Run rows, but retains
+   * complete usage totals by phase. Prefer those aggregates when supplied so
+   * an aggregate-only overview never presents them as empty data.
+   */
+  summaryUsage?: Pick<UsageProjection, "conversation" | "planning" | "execution" | "total">;
   currency: CostCurrency;
   locale: CostLocale;
 }) {
   const copy = costChartsCopy(locale);
-  const tokenMix = [
-    [copy.input, observed(rows.map((row) => row.input_tokens))],
-    [copy.cache, observed(rows.map((row) => row.cached_input_tokens))],
-    [copy.output, observed(rows.map((row) => row.output_tokens))],
-    [copy.reasoning, observed(rows.map((row) => row.reasoning_tokens))],
-  ] as const;
+  const tokenMix = chartTokenMix(rows, summaryUsage, copy);
   const availableModels = modelsWithObservedCost(models, currency);
   const maxModel = Math.max(1, ...availableModels.map((row) => cost(row, currency) ?? 0));
   const sevenDays = lastSevenDays(daily, currency);
-  const maxDaily = Math.max(1, ...sevenDays.map((day) => day.value));
+  const maxDaily = Math.max(1, ...sevenDays.map((day) => day.value ?? 0));
   const trendPoints = sevenDays.map((day, index) => ({
     ...day,
     x: (index / (sevenDays.length - 1)) * 100,
-    y: 82 - (day.value / maxDaily) * 58,
+    y: 82 - ((day.value ?? 0) / maxDaily) * 58,
   }));
   const points = trendPoints.map((point) => `${point.x},${point.y}`).join(" ");
   return (
@@ -73,7 +76,7 @@ export function CostCharts({
               key={point.key}
               style={{ left: `${point.x}%`, top: `${point.y}%` }}
             >
-              {formatCurrency(point.value, currency, locale)}
+              {formatNullableCurrency(point.value, currency, locale)}
             </span>
           ))}
         </div>
@@ -102,7 +105,7 @@ export function CostCharts({
                   }}
                 />
               </i>
-              <strong>{formatCurrency(cost(row, currency), currency, locale)}</strong>
+              <strong>{formatNullableCurrency(cost(row, currency), currency, locale)}</strong>
             </div>
           ))}
         </div>
@@ -119,7 +122,7 @@ export function CostCharts({
             <div key={label}>
               <i style={{ background: colors[index] }} />
               <span>{label}</span>
-              <strong>{formatCompactNumber(value, locale)}</strong>
+              <strong>{formatNullableNumber(value, locale)}</strong>
             </div>
           ))}
         </div>
@@ -133,12 +136,7 @@ export function CostCharts({
         </header>
         <div className="phase-strip">
           {(["conversation", "planning", "execution"] as const).map((phase, index) => {
-            const phaseRows = rows.filter((row) => row.phase === phase);
-            const duration = observed(phaseRows.map((row) => row.duration_ms));
-            const tokens = observed(phaseRows.map((row) => row.total_tokens));
-            const phaseCost = observed(
-              phaseRows.map((row) => (currency === "BRL" ? row.estimated_brl : row.estimated_usd)),
-            );
+            const metrics = chartPhaseMetrics(phase, rows, summaryUsage, currency);
             return (
               <div key={phase}>
                 <div className="phase-name">
@@ -148,15 +146,15 @@ export function CostCharts({
                 <dl className="phase-metrics">
                   <div>
                     <dt>{locale === "pt-BR" ? "Tempo" : "Time"}</dt>
-                    <dd>{formatDurationMs(duration, locale)}</dd>
+                    <dd>{formatNullableDuration(metrics.duration, locale)}</dd>
                   </div>
                   <div>
                     <dt>Tokens</dt>
-                    <dd>{formatCompactNumber(tokens, locale)}</dd>
+                    <dd>{formatNullableNumber(metrics.tokens, locale)}</dd>
                   </div>
                   <div>
                     <dt>{locale === "pt-BR" ? "Custo" : "Cost"}</dt>
-                    <dd>{formatCurrency(phaseCost, currency, locale)}</dd>
+                    <dd>{formatNullableCurrency(metrics.cost, currency, locale)}</dd>
                   </div>
                 </dl>
               </div>
@@ -168,6 +166,81 @@ export function CostCharts({
   );
 }
 
+export function chartTokenMix(
+  rows: readonly CostRunRow[],
+  summaryUsage: Pick<UsageProjection, "total"> | undefined,
+  copy: Pick<ReturnType<typeof costChartsCopy>, "inputWithoutCache" | "cachedInput" | "visibleOutput" | "reasoning" | "total">,
+) {
+  const tokens = summaryUsage?.total.tokens;
+  const input = tokens?.input ?? observed(rows.map((row) => row.input_tokens));
+  const cachedInput = subsetTokenTotal(
+    tokens?.cached_input ?? observed(rows.map((row) => row.cached_input_tokens)),
+    input,
+  );
+  const output = tokens?.output ?? observed(rows.map((row) => row.output_tokens));
+  const reasoning = subsetTokenTotal(
+    tokens?.reasoning ?? observed(rows.map((row) => row.reasoning_tokens)),
+    output,
+  );
+  const total = inclusiveTokenTotal(
+    input,
+    output,
+    tokens?.total ?? observed(rows.map((row) => row.total_tokens)),
+  );
+  return [
+    // Cache is inside Input and reasoning is inside Output. The chart must
+    // show mutually exclusive remainders rather than overlapping totals.
+    [copy.inputWithoutCache, exclusiveTokenRemainder(input, cachedInput)],
+    [copy.cachedInput, cachedInput],
+    [copy.visibleOutput, exclusiveTokenRemainder(output, reasoning)],
+    [copy.reasoning, reasoning],
+    [copy.total, total],
+  ] as const;
+}
+
+export function chartPhaseMetrics(
+  phase: "conversation" | "planning" | "execution",
+  rows: readonly CostRunRow[],
+  summaryUsage: Pick<UsageProjection, "conversation" | "planning" | "execution"> | undefined,
+  currency: CostCurrency,
+) {
+  const phaseRows = rows.filter((row) => row.phase === phase);
+  const usage = summaryUsage?.[phase];
+  return {
+    // Aggregate-only data carries observed invocation duration by phase. It
+    // remains distinct from the canonical root-Run wall-clock duration.
+    duration:
+      usage?.duration_ms ??
+      observed(
+        phaseRows.map((row) =>
+          row.duration_provenance === "observed" ||
+          row.duration_provenance === "reconciled" ||
+          row.duration_provenance === "legacy_inferred"
+            ? row.duration_ms
+            : null,
+        ),
+      ),
+    tokens: usage?.tokens.total ?? observed(phaseRows.map((row) => row.total_tokens)),
+    cost:
+      (currency === "BRL" ? usage?.cost.brl : usage?.cost.usd) ??
+      observed(
+        phaseRows.map((row) => (currency === "BRL" ? row.estimated_brl : row.estimated_usd)),
+      ),
+  };
+}
+
+function formatNullableDuration(value: number | null, locale: CostLocale) {
+  return value === null || value === 0 ? "0" : formatDurationMs(value, locale);
+}
+
+function formatNullableNumber(value: number | null, locale: CostLocale) {
+  return formatCompactNumber(value ?? 0, locale);
+}
+
+function formatNullableCurrency(value: number | null, currency: CostCurrency, locale: CostLocale) {
+  return formatCurrency(value ?? 0, currency, locale);
+}
+
 export function costChartsCopy(locale: CostLocale) {
   return locale === "pt-BR"
     ? {
@@ -182,10 +255,11 @@ export function costChartsCopy(locale: CostLocale) {
         tokenMix: "Mix de tokens",
         phases: "FASES",
         totalsByPhase: "Totais por fase",
-        input: "Entrada",
-        cache: "Cache",
-        output: "Saída",
+        inputWithoutCache: "Input sem cache",
+        cachedInput: "Cache",
+        visibleOutput: "Output visível",
         reasoning: "Raciocínio",
+        total: "Total (input + output)",
       }
     : {
         analyticsView: "Analytics overview",
@@ -199,10 +273,11 @@ export function costChartsCopy(locale: CostLocale) {
         tokenMix: "Token mix",
         phases: "PHASES",
         totalsByPhase: "Totals by phase",
-        input: "Input",
-        cache: "Cache",
-        output: "Output",
+        inputWithoutCache: "Uncached input",
+        cachedInput: "Cached input",
+        visibleOutput: "Visible output",
         reasoning: "Reasoning",
+        total: "Total (input + output)",
       };
 }
 
@@ -221,29 +296,45 @@ function cost(row: CostGroupRow, currency: CostCurrency) {
 }
 
 export function modelsWithObservedCost(models: readonly CostGroupRow[], currency: CostCurrency) {
-  return models.filter((row) => cost(row, currency) !== null);
+  return models
+    .filter((row) => cost(row, currency) !== null)
+    .sort((left, right) => {
+      const difference = (cost(right, currency) ?? 0) - (cost(left, currency) ?? 0);
+      return difference !== 0 ? difference : left.key.localeCompare(right.key);
+    });
+}
+
+function subsetTokenTotal(subset: number | null, total: number | null): number | null {
+  if (subset === null || total === null || subset > total) return null;
+  return subset;
+}
+
+function exclusiveTokenRemainder(total: number | null, subset: number | null): number | null {
+  return total === null || subset === null ? null : total - subset;
+}
+
+function inclusiveTokenTotal(
+  input: number | null,
+  output: number | null,
+  reportedTotal: number | null,
+): number | null {
+  return input !== null && output !== null ? input + output : reportedTotal;
 }
 
 export function lastSevenDays(
   daily: readonly CostGroupRow[],
   currency: CostCurrency,
-  now = new Date(),
 ) {
-  const values = new Map(daily.map((row) => [row.key, cost(row, currency) ?? 0]));
-  return Array.from({ length: 7 }, (_, index) => {
-    const date = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (6 - index));
-    const key = localDateKey(date);
-    return { date, key, value: values.get(key) ?? 0 };
+  const values = new Map(daily.map((row) => [row.key, cost(row, currency)]));
+  const buckets = [...values.keys()].sort().slice(-7);
+  return buckets.map((key) => {
+    const date = new Date(`${key}T12:00:00`);
+    // A missing calendar bucket is a real zero; a present bucket with missing
+    // financial telemetry remains unavailable rather than being coerced to zero.
+    return { date, key, value: values.get(key)! };
   });
 }
 
-function localDateKey(date: Date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
 function formatTrendDay(date: Date, locale: CostLocale) {
   return new Intl.DateTimeFormat(locale, {
     weekday: "short",

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

@@ -4,7 +4,8 @@ import type { CostMonitorProjection } from "../contracts.js";
 import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
 
 export type CostPeriod = "all" | "7" | "30" | "90" | "month";
-export const defaultCostPeriod: CostPeriod = "all";
+/** Cost Monitor opens on the current Sao Paulo month, matching Operations. */
+export const defaultCostPeriod: CostPeriod = "month";
 
 export function costPeriodDateRange(
   period: CostPeriod,
@@ -38,6 +39,9 @@ export async function loadCostMonitorPeriod({
   fetcher?: typeof fetch;
 }): Promise<CostMonitorProjection> {
   const query = new URLSearchParams({ currency });
+  // Period and filter changes hydrate aggregate read models only. Entity
+  // detail is loaded through its dedicated bounded page route.
+  query.set("scope", "summary");
   if (from !== undefined) query.set("from", from);
   if (to !== undefined) query.set("to", to);
   if (filters) {
@@ -63,6 +67,123 @@ export async function loadCostMonitorPeriod({
   return (await response.json()) as CostMonitorProjection;
 }
 
+/** Exact dimensional projection, requested only after a dimensional tab opens. */
+export async function loadCostMonitorDetail({
+  currency,
+  filters,
+  from,
+  refresh,
+  to,
+  signal,
+  fetcher = fetch,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  refresh?: string | null;
+  to?: string;
+  signal?: AbortSignal;
+  fetcher?: typeof fetch;
+}): Promise<CostMonitorProjection> {
+  const query = costMonitorQuery({
+    currency,
+    ...(filters === undefined ? {} : { filters }),
+    ...(from === undefined ? {} : { from }),
+    ...(refresh === undefined ? {} : { refresh }),
+    ...(to === undefined ? {} : { to }),
+  });
+  query.set("scope", "detail");
+  const response = await fetcher(`/api/v2/cost-monitor?${query.toString()}`, {
+    ...(signal === undefined ? {} : { signal }),
+  });
+  if (!response.ok)
+    throw new Error(
+      (await response.text()).trim() || `Cost Monitor detail request failed (${response.status})`,
+    );
+  return (await response.json()) as CostMonitorProjection;
+}
+
+export async function loadCostMonitorRunPage({
+  currency,
+  filters,
+  from,
+  offset,
+  refresh,
+  to,
+  signal,
+  fetcher = fetch,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  offset: number;
+  refresh?: string | null;
+  to?: string;
+  signal?: AbortSignal;
+  fetcher?: typeof fetch;
+}): Promise<CostRunPage> {
+  const query = costMonitorQuery({
+    currency,
+    ...(filters === undefined ? {} : { filters }),
+    ...(from === undefined ? {} : { from }),
+    ...(refresh === undefined ? {} : { refresh }),
+    ...(to === undefined ? {} : { to }),
+  });
+  query.set("scope", "runs");
+  query.set("offset", String(Math.max(0, offset)));
+  query.set("limit", "100");
+  const response = await fetcher(`/api/v2/cost-monitor?${query.toString()}`, {
+    ...(signal === undefined ? {} : { signal }),
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim();
+    throw new Error(detail || `Cost Monitor run page request failed (${response.status})`);
+  }
+  const payload = (await response.json()) as Pick<CostMonitorProjection, "runs" | "run_page">;
+  return {
+    page_only: true,
+    runs: payload.runs,
+    run_page: payload.run_page ?? { offset, limit: 100, total: null, has_more: false },
+  };
+}
+
+/** Complete contract for the incremental Run endpoint; it is not a summary projection. */
+export interface CostRunPage {
+  page_only: true;
+  runs: CostMonitorProjection["runs"];
+  run_page: { offset: number; limit: number; total: number | null; has_more: boolean };
+}
+
+function costMonitorQuery({
+  currency,
+  filters,
+  from,
+  refresh,
+  to,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  refresh?: string | null;
+  to?: string;
+}): URLSearchParams {
+  const query = new URLSearchParams({ currency });
+  if (from !== undefined) query.set("from", from);
+  if (to !== undefined) query.set("to", to);
+  if (filters) {
+    const manifestFilters = [
+      ["provider", filters.provider],
+      ["phase", filters.phase],
+      ["agent", filters.agent],
+      ["model", filters.model],
+      ["status", filters.status],
+    ] as const;
+    for (const [key, value] of manifestFilters) if (value) query.set(key, value);
+  }
+  if (refresh) query.set("refresh", refresh);
+  return query;
+}
+
 export function useCostMonitorPeriod({
   currency,
   data,
@@ -91,10 +212,14 @@ export function useCostMonitorPeriod({
   const [periodLoading, setPeriodLoading] = useState(false);
   const [periodError, setPeriodError] = useState<string | null>(null);
   const initialDataRef = useRef(true);
+  const loadPeriodRef = useRef(loadPeriod);
+  loadPeriodRef.current = loadPeriod;
   const requestedRange =
     dateRange === undefined
       ? costPeriodDateRange(period)
       : { from: dateRange.start, to: dateRange.end };
+  const requestedFrom = requestedRange?.from;
+  const requestedTo = requestedRange?.to;
   const shouldFetch = shouldFetchCostPeriod({ filters, period, snapshotBacked });
   useEffect(() => {
     if (!shouldFetch) {
@@ -109,13 +234,16 @@ export function useCostMonitorPeriod({
     const controller = new AbortController();
     setPeriodLoading(true);
     setPeriodError(null);
-    void loadPeriod({
-      currency,
-      filters,
-      ...(requestedRange === undefined ? {} : { from: requestedRange.from, to: requestedRange.to }),
-      refresh: lastUpdatedAt,
-      signal: controller.signal,
-    })
+    void loadPeriodRef
+      .current({
+        currency,
+        filters,
+        ...(requestedFrom === undefined || requestedTo === undefined
+          ? {}
+          : { from: requestedFrom, to: requestedTo }),
+        refresh: lastUpdatedAt,
+        signal: controller.signal,
+      })
       .then((nextPeriodData) => {
         if (controller.signal.aborted) return;
         setPeriodDataBase(data);
@@ -130,17 +258,7 @@ export function useCostMonitorPeriod({
         if (!controller.signal.aborted) setPeriodLoading(false);
       });
     return () => controller.abort();
-  }, [
-    currency,
-    data,
-    filters,
-    lastUpdatedAt,
-    loadPeriod,
-    requestedRange?.from,
-    requestedRange?.to,
-    shouldFetch,
-    requestedRange,
-  ]);
+  }, [currency, data, filters, lastUpdatedAt, requestedFrom, requestedTo, shouldFetch]);
   return {
     activeData: activeCostPeriodData(data, periodData, periodDataBase),
     periodError,

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostModelsAuditTable.test.ts

@@ -46,6 +46,8 @@ describe("CostModelsAuditTable coverage", () => {
     expect(tables).not.toContain("Partial ·");
     expect(tables).not.toContain("durationCoverageDetail");
     expect(models).not.toContain("durationCoverageDetail");
+    expect(models).not.toContain("tempo observado");
+    expect(models).not.toContain("observed time");
     expect(models).toContain("aggregateDurationCoverage");
   });
 });