@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/modules/cost-monitor/src/react/period-cost-groups.ts

@@ -20,6 +20,8 @@ interface PeriodEntities {
     result: { evidence_ids: string[] } | null;
     test_count?: number;
   }[];
+  evidences?: readonly { id: string; observed_at: string }[];
+  validations?: readonly { id: string; executed_at: string }[];
 }
 
 export function enrichPeriodCostGroups(
@@ -32,13 +34,17 @@ export function enrichPeriodCostGroups(
       row.key,
       {
         ...row,
-        tasksActive: row.tasksActive ?? row.task_count,
-        taskDaysActive: row.tasksActive ?? row.task_count,
+        // Period entity totals are creation-based; invocations remain in the
+        // Run columns and must not inflate the number of Tasks.
+        task_count: 0,
+        tasksActive: 0,
+        taskDaysActive: 0,
         tasksCreated: 0,
       },
     ]),
   );
   const evidenceIds = new Map<string, Set<string>>();
+  const typedEvidenceIds = new Set((entities.evidences ?? []).map((evidence) => evidence.id));
 
   const bucketFor = (value: string | null): CostGroupRow | null => {
     const key = periodKey(value, granularity);
@@ -81,16 +87,37 @@ export function enrichPeriodCostGroups(
   for (const task of entities.tasks) {
     const bucket = bucketFor(task.created_at);
     if (bucket === null) continue;
+    bucket.task_count = (bucket.task_count ?? 0) + 1;
     bucket.tasksCreated = (bucket.tasksCreated ?? 0) + 1;
-    bucket.test_count += task.test_count ?? 0;
+    if (entities.validations === undefined) bucket.test_count += task.test_count ?? 0;
     const ids = evidenceIds.get(bucket.key) ?? new Set<string>();
-    for (const evidenceId of task.result?.evidence_ids ?? []) ids.add(evidenceId);
+    for (const evidenceId of task.result?.evidence_ids ?? [])
+      if (!typedEvidenceIds.has(evidenceId)) ids.add(evidenceId);
+    evidenceIds.set(bucket.key, ids);
+  }
+  for (const evidence of entities.evidences ?? []) {
+    const bucket = bucketFor(evidence.observed_at);
+    if (bucket === null) continue;
+    const ids = evidenceIds.get(bucket.key) ?? new Set<string>();
+    ids.add(evidence.id);
     evidenceIds.set(bucket.key, ids);
   }
   for (const [key, ids] of evidenceIds) {
     const bucket = rows.get(key);
     if (bucket !== undefined) bucket.evidence_count = ids.size;
   }
+  const validationIds = new Map<string, Set<string>>();
+  for (const validation of entities.validations ?? []) {
+    const bucket = bucketFor(validation.executed_at);
+    if (bucket === null) continue;
+    const ids = validationIds.get(bucket.key) ?? new Set<string>();
+    ids.add(validation.id);
+    validationIds.set(bucket.key, ids);
+  }
+  for (const [key, ids] of validationIds) {
+    const bucket = rows.get(key);
+    if (bucket !== undefined) bucket.test_count = ids.size;
+  }
   return [...rows.values()].sort((left, right) => right.key.localeCompare(left.key));
 }
 
@@ -100,7 +127,8 @@ export function summarizeCostPeriodAverages(
 ): CostPeriodAverages {
   const divisor = rows.length;
   return {
-    tasks: divisor === 0 ? null : rows.reduce((sum, row) => sum + row.task_count, 0) / divisor,
+    tasks:
+      divisor === 0 ? null : rows.reduce((sum, row) => sum + (row.task_count ?? 0), 0) / divisor,
     specs: divisor === 0 ? null : rows.reduce((sum, row) => sum + row.spec_count, 0) / divisor,
     prds: divisor === 0 ? null : rows.reduce((sum, row) => sum + row.prd_count, 0) / divisor,
     durationMs: averagePerPeriod(

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-compact-cost-page.ts

@@ -0,0 +1,119 @@
+import { useEffect, useRef, useState } from "react";
+import {
+  type CompactLifecycleCostPage,
+  withTokenBackedCompactDuration,
+} from "./CompactLifecycleCostTable.js";
+import type { CostFilterState } from "./CostFilters.js";
+import type { CostView } from "./cost-monitor-views.js";
+
+type CompactReadModelKind = CompactLifecycleCostPage["kind"];
+export type LoadCompactCostPage = (request: {
+  kind: CompactReadModelKind;
+  from?: string;
+  to?: string;
+  offset: number;
+  limit: number;
+  query?: string;
+  filters: CostFilterState;
+  signal?: AbortSignal;
+}) => Promise<CompactLifecycleCostPage>;
+
+export function compactReadModelKind(view: CostView): CompactReadModelKind | null {
+  return view === "tasks" ||
+    view === "specs" ||
+    view === "prds" ||
+    view === "executions" ||
+    view === "conversations"
+    ? view
+    : null;
+}
+
+export function useCompactCostPage({
+  view,
+  load,
+  range,
+  query,
+  filters,
+}: {
+  view: CostView;
+  load: LoadCompactCostPage | undefined;
+  range: { from: string; to: string } | undefined;
+  query: string | undefined;
+  filters: CostFilterState;
+}) {
+  const [offset, setOffset] = useState(0);
+  const [page, setPage] = useState<CompactLifecycleCostPage | null>(null);
+  const [resolvedKey, setResolvedKey] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [attempt, setAttempt] = useState(0);
+  const generationRef = useRef(0);
+  const loadRef = useRef(load);
+  loadRef.current = load;
+  const hasLoad = load !== undefined;
+  const rangeFrom = range?.from;
+  const rangeTo = range?.to;
+  const filterKey = Object.values(filters).join("\u0000");
+  const paginationKey = `${view}\u0000${query ?? ""}\u0000${rangeFrom ?? ""}\u0000${rangeTo ?? ""}\u0000${filterKey}`;
+  const requestKey = `${paginationKey}\u0000${offset}`;
+  const requestInputRef = useRef({ filters, query, rangeFrom, rangeTo });
+  requestInputRef.current = { filters, query, rangeFrom, rangeTo };
+  useEffect(() => {
+    void paginationKey;
+    setOffset(0);
+  }, [paginationKey]);
+  useEffect(() => {
+    void attempt;
+    const kind = compactReadModelKind(view);
+    if (kind === null || !hasLoad) {
+      setPage(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    const generation = ++generationRef.current;
+    setLoading(true);
+    setError(null);
+    const loadPage = loadRef.current;
+    if (loadPage === undefined) return;
+    const requestInput = requestInputRef.current;
+    void loadPage({
+      kind,
+      offset,
+      limit: 50,
+      ...(requestInput.rangeFrom === undefined || requestInput.rangeTo === undefined
+        ? {}
+        : { from: requestInput.rangeFrom, to: requestInput.rangeTo }),
+      ...(requestInput.query ? { query: requestInput.query } : {}),
+      filters: requestInput.filters,
+      signal: controller.signal,
+    })
+      .then((next) => {
+        if (!controller.signal.aborted && generation === generationRef.current) {
+          setPage({ ...next, rows: next.rows.map(withTokenBackedCompactDuration) });
+          setResolvedKey(requestKey);
+        }
+      })
+      .catch((cause: unknown) => {
+        if (!controller.signal.aborted && generation === generationRef.current)
+          setError(cause instanceof Error ? cause.message : String(cause));
+      })
+      .finally(() => {
+        if (!controller.signal.aborted && generation === generationRef.current) setLoading(false);
+      });
+    return () => controller.abort();
+    // App supplies an inline loader. Its identity changes after state updates;
+    // retaining it here would abort/restart this exact request forever.
+  }, [attempt, hasLoad, offset, requestKey, view]);
+  return {
+    compactPageOffset: offset,
+    setCompactPageOffset: setOffset,
+    // A response for another tab, range, filter, or offset must never occupy
+    // this view while the next request is in flight.
+    compactPage: resolvedKey === requestKey ? page : null,
+    compactPageLoading: loading,
+    compactPageError: error,
+    retryCompactPage: () => setAttempt((value) => value + 1),
+  };
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-cost-group-page.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { isCurrentCostGroupPage } from "./use-cost-group-page.js";
+
+describe("Cost group page request identity", () => {
+  it("masks a resolved monthly page while the annual request is pending", () => {
+    const monthly = "monthly\u0000\u0000\u0000\u0000\u00000";
+    const annual = "annual\u0000\u0000\u0000\u0000\u00000";
+
+    expect(isCurrentCostGroupPage(monthly, annual)).toBe(false);
+    expect(isCurrentCostGroupPage(annual, annual)).toBe(true);
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-cost-group-page.ts

@@ -0,0 +1,146 @@
+import { useEffect, useRef, useState } from "react";
+import type { CostGroupRow } from "../contracts.js";
+import type { CostFilterState } from "./CostFilters.js";
+import type { CostLocale } from "./cost-monitor-copy.js";
+
+/** Pre-pagination aggregate for the exact page query. */
+export type CostGroupTotals = Pick<
+  CostGroupRow,
+  | "run_count"
+  | "task_count"
+  | "prd_count"
+  | "spec_count"
+  | "evidence_count"
+  | "test_count"
+  | "event_count"
+  | "total_tokens"
+  | "estimated_usd"
+  | "estimated_brl"
+  | "duration_ms"
+  | "duration"
+>;
+export type CostGroupPage = {
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  rows: readonly CostGroupRow[];
+  totals?: CostGroupTotals;
+};
+export type CostGroupFilters = CostFilterState;
+export type LoadCostGroupPage = (request: {
+  view: "daily" | "monthly" | "annual" | "agents" | "models" | "providers";
+  from?: string;
+  to?: string;
+  offset: number;
+  limit: number;
+  query?: string;
+  filters: CostGroupFilters;
+  signal?: AbortSignal;
+}) => Promise<CostGroupPage>;
+
+export function effectiveCostGroupQuery(filters: CostGroupFilters, globalQuery: string): string {
+  return filters.query || globalQuery;
+}
+
+/** A resolved page belongs to one exact tab, range, filter and offset. */
+export function isCurrentCostGroupPage(resolvedKey: string | null, requestKey: string): boolean {
+  return resolvedKey === requestKey;
+}
+
+export function costGroupPageLabel({
+  locale,
+  page,
+}: {
+  locale: CostLocale;
+  page: { offset: number; limit: number; total_count: number };
+}): string {
+  if (page.total_count === 0) return locale === "pt-BR" ? "Nenhum resultado" : "No results";
+  return `${page.offset + 1}–${Math.min(page.offset + page.limit, page.total_count)} ${locale === "pt-BR" ? "de" : "of"} ${page.total_count}`;
+}
+
+/**
+ * Temporal rows can be paged independently, but card-backed columns must keep
+ * the exact population shown by the dashboard big numbers.
+ */
+export function reconcileCostGroupTotalsWithCards(
+  pageTotals: CostGroupTotals,
+  cardTotals: CostGroupTotals,
+): CostGroupTotals {
+  return {
+    ...pageTotals,
+    task_count: cardTotals.task_count,
+    prd_count: cardTotals.prd_count,
+    spec_count: cardTotals.spec_count,
+    total_tokens: cardTotals.total_tokens,
+    estimated_brl: cardTotals.estimated_brl,
+    duration_ms: cardTotals.duration_ms,
+    duration: cardTotals.duration,
+  };
+}
+
+export function useCostGroupPage({
+  view,
+  range,
+  globalQuery,
+  filters,
+  load,
+}: {
+  view: "daily" | "monthly" | "annual" | "agents" | "models" | "providers";
+  range?: { from: string; to: string };
+  globalQuery: string;
+  filters: CostGroupFilters;
+  load?: LoadCostGroupPage;
+}) {
+  const [offset, setOffset] = useState(0);
+  const [page, setPage] = useState<CostGroupPage | null>(null);
+  const [resolvedKey, setResolvedKey] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const generation = useRef(0);
+  const loader = useRef(load);
+  loader.current = load;
+  const query = effectiveCostGroupQuery(filters, globalQuery);
+  const filterKey = `${Object.values(filters).join("\u0000")}\u0000${query}`;
+  const paginationKey = `${view}\u0000${range?.from ?? ""}\u0000${range?.to ?? ""}\u0000${filterKey}`;
+  const requestKey = `${paginationKey}\u0000${offset}`;
+  const requestInputRef = useRef({ filters, query, range, view });
+  requestInputRef.current = { filters, query, range, view };
+  useEffect(() => {
+    void paginationKey;
+    setOffset(0);
+  }, [paginationKey]);
+  useEffect(() => {
+    if (!loader.current) return;
+    const controller = new AbortController();
+    const current = ++generation.current;
+    const requestInput = requestInputRef.current;
+    const limit = requestInput.view === "daily" ? 30 : 50;
+    setLoading(true);
+    void loader
+      .current({
+        view: requestInput.view,
+        offset,
+        limit,
+        ...(requestInput.query ? { query: requestInput.query } : {}),
+        filters: requestInput.filters,
+        ...(requestInput.range ?? {}),
+        signal: controller.signal,
+      })
+      .then((next) => {
+        if (!controller.signal.aborted && current === generation.current) {
+          setPage(next);
+          setResolvedKey(requestKey);
+        }
+      })
+      .finally(() => {
+        if (!controller.signal.aborted && current === generation.current) setLoading(false);
+      });
+    return () => controller.abort();
+  }, [offset, requestKey]);
+  return {
+    page: isCurrentCostGroupPage(resolvedKey, requestKey) ? page : null,
+    loading,
+    offset,
+    setOffset,
+  };
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/use-cost-run-page.ts

@@ -0,0 +1,118 @@
+import { useEffect, useRef, useState } from "react";
+import { type CostFilterState, type CostRunPage, loadCostMonitorRunPage } from "./CostFilters.js";
+import type { CostCurrency } from "./cost-monitor-copy.js";
+import { isCurrentCostRunPageGeneration } from "./cost-monitor-page-helpers.js";
+import type { CostView } from "./cost-monitor-views.js";
+
+export function useCostRunPage({
+  view,
+  eligible,
+  currency,
+  filters,
+  globalQuery,
+  range,
+  refresh,
+  load,
+}: {
+  view: CostView;
+  eligible: boolean;
+  currency: CostCurrency;
+  filters: CostFilterState;
+  globalQuery: string;
+  range: { from: string; to: string } | undefined;
+  refresh: string | null;
+  load: typeof loadCostMonitorRunPage | undefined;
+}) {
+  const [offset, setOffset] = useState(0);
+  const [data, setData] = useState<CostRunPage | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [attempt, setAttempt] = useState(0);
+  const generationRef = useRef(0);
+  const loadRef = useRef(load);
+  loadRef.current = load;
+  const rangeFrom = range?.from;
+  const rangeTo = range?.to;
+  const effectiveFilters = { ...filters, query: filters.query || globalQuery };
+  const paginationKey = `${Object.values(effectiveFilters).join("\u0000")}\u0000${rangeFrom ?? ""}\u0000${rangeTo ?? ""}`;
+  const requestKey = `${view}\u0000${eligible}\u0000${currency}\u0000${paginationKey}\u0000${refresh ?? ""}`;
+  const requestInputRef = useRef({
+    view,
+    eligible,
+    currency,
+    effectiveFilters,
+    rangeFrom,
+    rangeTo,
+    refresh,
+  });
+  requestInputRef.current = {
+    view,
+    eligible,
+    currency,
+    effectiveFilters,
+    rangeFrom,
+    rangeTo,
+    refresh,
+  };
+  useEffect(() => {
+    void paginationKey;
+    setOffset(0);
+  }, [paginationKey]);
+  useEffect(() => {
+    void attempt;
+    void requestKey;
+    const requestInput = requestInputRef.current;
+    if (requestInput.view !== "agentCalls" || !requestInput.eligible) {
+      setData(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    const generation = ++generationRef.current;
+    setLoading(true);
+    setError(null);
+    void (loadRef.current ?? loadCostMonitorRunPage)({
+      currency: requestInput.currency,
+      filters: requestInput.effectiveFilters,
+      ...(requestInput.rangeFrom === undefined || requestInput.rangeTo === undefined
+        ? {}
+        : { from: requestInput.rangeFrom, to: requestInput.rangeTo }),
+      offset,
+      refresh: requestInput.refresh,
+      signal: controller.signal,
+    })
+      .then((next) => {
+        if (
+          !controller.signal.aborted &&
+          isCurrentCostRunPageGeneration(generation, generationRef.current)
+        )
+          setData(next);
+      })
+      .catch((cause: unknown) => {
+        if (
+          !controller.signal.aborted &&
+          isCurrentCostRunPageGeneration(generation, generationRef.current)
+        )
+          setError(cause instanceof Error ? cause.message : String(cause));
+      })
+      .finally(() => {
+        if (
+          !controller.signal.aborted &&
+          isCurrentCostRunPageGeneration(generation, generationRef.current)
+        )
+          setLoading(false);
+      });
+    return () => controller.abort();
+    // Do not depend on App's inline loader identity: a render caused by loading
+    // state must not cancel and recreate the same page request.
+  }, [attempt, offset, requestKey]);
+  return {
+    runPageOffset: offset,
+    setRunPageOffset: setOffset,
+    runPageData: data,
+    runPageLoading: loading,
+    runPageError: error,
+    retryRunPage: () => setAttempt((value) => value + 1),
+  };
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/server/aggregate.test.ts

@@ -94,7 +94,7 @@ describe("aggregateRows", () => {
     ];
 
     expect(aggregateRows(rows, () => "TASK-1")[0]).toMatchObject({
-      duration_ms: null,
+      duration_ms: 0,
       duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
     });
   });
@@ -190,7 +190,7 @@ describe("aggregateRows", () => {
     ];
 
     expect(aggregateRows(rows, () => "2026-07-15")[0]).toMatchObject({
-      duration_ms: null,
+      duration_ms: 2_000,
       duration: { known_sum: 2_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
     });
   });

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

@@ -26,7 +26,7 @@ export function aggregateRows(
       // incorrectly becomes a second visible root inside its local group.
       const duration = aggregateDurationCoverage(
         group.filter((row) => durationContributorIds.has(row.run_id)),
-        durationScope === "all_execution" ? "all_execution" : "all_invocations",
+        durationScope,
       );
       return {
         key,
@@ -46,11 +46,13 @@ export function aggregateRows(
         spec_count: 0,
         evidence_count: 0,
         test_count: 0,
-        event_count: group.reduce((total, row) => total + row.event_count, 0),
+        event_count: group.reduce((total, row) => total + (row.event_count ?? 0), 0),
         total_tokens: completeSum(group.map((row) => row.total_tokens)),
         estimated_usd: completeSum(group.map((row) => row.estimated_usd)),
         estimated_brl: completeSum(group.map((row) => row.estimated_brl)),
-        duration_ms: duration.complete ? duration.known_sum : null,
+        // Partial populations keep their observed sum; coverage preserves the
+        // unknown count and completeness while individual Runs remain null.
+        duration_ms: duration.known_sum,
         duration,
         coverage: mergeCoverage(group),
       };

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-monitor-pricing-fallback.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { buildCostMonitorProjection } from "./build-cost-monitor-projection.js";
+import {
+  fxRate,
+  gpt54Catalog,
+  metric,
+  operationsWithPricedRun,
+  usage,
+} from "./build-cost-monitor-projection.test-fixtures.js";
+
+describe("Cost Monitor pricing fallback", () => {
+  it("preserves recorded cost when the current catalog cannot price a supported tier combination", () => {
+    const operations = operationsWithPricedRun();
+    const run = operations.runs[0];
+    if (!run) throw new Error("priced Run fixture is missing");
+    run.model = "gpt-5.4";
+    run.effective_model = "gpt-5.4";
+    run.service_tier = "priority";
+    run.usage = usage(
+      metric({
+        tokens: 400_000,
+        input: 300_000,
+        cached: 200_000,
+        output: 100_000,
+        reasoning: 20_000,
+        usd: 2,
+        brl: 10,
+        events: 1,
+      }),
+    );
+    const projection = buildCostMonitorProjection(operations, {
+      catalog: gpt54Catalog(),
+      fxRate: fxRate(5.5),
+      currency: "BRL",
+    });
+    expect(projection.runs[0]).toMatchObject({
+      service_tier: "priority",
+      input_rate_usd_per_million: 2.5,
+      cached_input_rate_usd_per_million: 0.25,
+      output_rate_usd_per_million: 15,
+      input_cost_usd: 0.5,
+      cached_input_cost_usd: 0.1,
+      output_cost_usd: 2.25,
+      reasoning_cost_usd: 0,
+      standard_cost_usd: 2.85,
+      speed_cost_multiplier: null,
+      speed_uplift_usd: null,
+      estimated_usd: 2,
+      estimated_brl: 10,
+      coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+    });
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-monitor-projection.basics.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCostMonitorProjection,
+  effectiveCostRunPhase,
+} from "./build-cost-monitor-projection.js";
+import { operationsWithPricedRun } from "./build-cost-monitor-projection.test-fixtures.js";
+
+describe("Cost Monitor V2 basics", () => {
+  it("normalizes legacy Task captures without calling them conversations", () => {
+    expect(effectiveCostRunPhase({ entrypoint: "task", phase: "conversation" })).toBe("planning");
+    expect(effectiveCostRunPhase({ entrypoint: "task", phase: "execution" })).toBe("execution");
+    expect(effectiveCostRunPhase({ entrypoint: "conversation", phase: "conversation" })).toBe(
+      "conversation",
+    );
+  });
+
+  it("merges missing, unknown, codex, and openai provider rows into openai", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs = [null, "unknown", "codex", "openai"].map((provider, index) => ({
+      ...source,
+      id: `RUN-PROVIDER-${index}`,
+      provider,
+    }));
+
+    const projection = buildCostMonitorProjection(operations);
+
+    expect(projection.filters_available.providers).toEqual(["openai"]);
+    expect(projection.groups.providers).toHaveLength(1);
+    expect(projection.groups.providers[0]).toMatchObject({ key: "openai", run_count: 4 });
+    expect(projection.runs.every((run) => run.provider === "openai")).toBe(true);
+  });
+});