@zaip-ai/cli 1.3.7 → 1.4.1

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

@@ -1,6 +1,5 @@
-import { createHash } from "node:crypto";
-import { queryInvocationManifestPeriod } from "@zaip-ai/costs";
 import { describe, expect, it } from "vitest";
+import type { CostGroupRow } from "../contracts.js";
 import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
 import {
   agentRunModelPresentation,
@@ -140,10 +139,10 @@ describe("monetary formatting", () => {
     expect(ratio(106.73, 19.583444)).toBeCloseTo(5.45, 2);
     expect(ratio(100, 0)).toBeNull();
   });
-  it("renders unavailable numeric metrics as zero", () => {
+  it("keeps unavailable cost metrics distinct from zero", () => {
     expect(formatRate(null, "pt-BR")).toBe("0,00");
     expect(formatUsd(null, "en-US")).toContain("0.00");
-    expect(formatAuditableCurrency(null, "BRL", "pt-BR")).toContain("0,00");
+    expect(formatAuditableCurrency(null, "BRL", "pt-BR")).toBe("Indisponível");
     expect(formatAuditableDuration(null, "pt-BR")).toBe("Indisponível");
     expect(formatAuditableCompactNumber(null, "pt-BR")).toBe("0");
   });
@@ -384,11 +383,11 @@ describe("grouped cost availability", () => {
     expect(table.props.scrollLabel).toBe(costGroupsScrollLabel("pt-BR"));
     expect(column("duration")?.render(unavailableGroup)).toBe("Indisponível");
     expect(column("tokens")?.render(unavailableGroup)).toBe("0");
-    expect(column("cost")?.render(unavailableGroup)).toContain("0,00");
+    expect(column("cost")?.render(unavailableGroup)).toBe("Indisponível");
     expect(column("duration")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("tokens")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("cost")?.sortValue?.(unavailableGroup)).toBeNull();
-    const totalSummary = "Total geral — Tempo: Indisponível; Tokens: 0; BRL: R$ 0,00";
+    const totalSummary = "Total geral — Tempo: Indisponível; Tokens: 0; BRL: Indisponível";
     const footerLabel = (key: string) => {
       const footer = column(key)?.footer as { props?: { "aria-label"?: string } } | undefined;
       return footer?.props?.["aria-label"];
@@ -462,9 +461,36 @@ describe("grouped cost availability", () => {
     expect(columns.find((column) => column.key === "job")?.render?.({ job: "Builder" })).toBe(
       "Builder",
     );
-    expect(columns.find((column) => column.key === "tasks")).toBeUndefined();
+    expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tarefas");
     expect(table.props.defaultSort).toEqual({ key: "cost", direction: "desc" });
   });
+
+  it("renders missing Agent numeric metrics as zero, keeping model rendering independent", () => {
+    const missing: CostGroupRow = {
+      ...unavailableGroup,
+      task_count: null,
+      prd_count: null,
+      spec_count: null,
+      test_count: null,
+      evidence_count: null,
+    };
+    const table = CostGroupsTable({
+      rows: [missing],
+      currency: "BRL",
+      locale: "pt-BR",
+      showAgentIdentity: true,
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      render?: (row: CostGroupRow) => unknown;
+      footer?: unknown;
+    }>;
+    for (const key of ["tasks", "prds", "specs", "tests", "evidences", "duration", "tokens"]) {
+      expect(columns.find((c) => c.key === key)?.render?.(missing)).toBe("0");
+    }
+    expect(columns.find((c) => c.key === "cost")?.render?.(missing)).not.toContain("Indisponível");
+  });
+
   it("keeps legacy codex identity fields blank and uses the complete paged aggregate in its footer", () => {
     const table = CostGroupsTable({
       rows: [
@@ -518,6 +544,123 @@ describe("grouped cost availability", () => {
     expect(columns.find((column) => column.key === "latestStartedAt")?.hidden).toBe(true);
     expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tarefas com invocação");
   });
+  it("renders the requested model-analysis columns with explicit numeric zeroes", () => {
+    const model: CostGroupRow = {
+      ...unavailableGroup,
+      key: "gpt-6-astra",
+      label: "gpt-6-astra",
+      prd_count: 2,
+      spec_count: 3,
+      task_count: null,
+      run_count: 8,
+      test_count: null,
+      evidence_count: 1,
+      conversation_count: 0,
+    };
+    const table = CostGroupsTable({
+      rows: [model],
+      currency: "BRL",
+      locale: "pt-BR",
+      showDateTime: false,
+      showModelLifecycleDetails: true,
+      totals: {
+        ...model,
+        prd_count: 2,
+        spec_count: 3,
+        task_count: null,
+        test_count: null,
+        evidence_count: 1,
+      },
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      label: string;
+      render?: (row: typeof model) => unknown;
+      sortValue?: (row: typeof model) => unknown;
+      description?: string;
+    }>;
+    expect(columns.map((column) => column.key).filter((key) => key !== "latestStartedAt")).toEqual([
+      "label",
+      "prds",
+      "specs",
+      "tasks",
+      "conversations",
+      "runs",
+      "tests",
+      "evidences",
+      "duration",
+      "tokens",
+      "cost",
+    ]);
+    expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tasks");
+    expect(columns.find((column) => column.key === "tasks")?.render?.(model)).toBe("0");
+    expect(columns.find((column) => column.key === "conversations")?.render?.(model)).toBe("0");
+    expect(columns.find((column) => column.key === "conversations")?.description).toContain(
+      "unassisted",
+    );
+    expect(columns.find((column) => column.key === "tasks")?.description).toContain(
+      "creation_run_id",
+    );
+    expect(columns.find((column) => column.key === "runs")?.description).toContain(
+      "sem distribuir",
+    );
+    for (const key of ["prds", "specs", "tasks", "conversations", "runs", "tests", "evidences"])
+      expect(columns.find((column) => column.key === key)?.sortValue).toBeDefined();
+    expect(columns.find((column) => column.key === "cost")?.label).toBe("Custos");
+    expect(
+      columns.find((column) => column.key === "tokens")?.render?.({ ...model, total_tokens: null }),
+    ).toBe("0");
+    expect(
+      columns.find((column) => column.key === "prds")?.render?.({ ...model, prd_count: null }),
+    ).toBe("0");
+    expect(
+      columns.find((column) => column.key === "specs")?.render?.({ ...model, spec_count: null }),
+    ).toBe("0");
+    expect(
+      columns.find((column) => column.key === "tests")?.render?.({ ...model, test_count: null }),
+    ).toBe("0");
+    expect(
+      columns
+        .find((column) => column.key === "evidences")
+        ?.render?.({ ...model, evidence_count: null }),
+    ).toBe("0");
+    expect(columns.find((column) => column.key === "conversations")?.sortValue?.(model)).toBe(0);
+    expect(columns.find((column) => column.key === "tests")?.description).toContain(
+      "Run registradora",
+    );
+    expect(columns.find((column) => column.key === "evidences")?.description).toContain(
+      "Run registradora",
+    );
+    expect(
+      columns
+        .find((column) => column.key === "duration")
+        ?.render?.({
+          ...model,
+          duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
+        }),
+    ).toBe("0");
+    expect(
+      columns.find((column) => column.key === "cost")?.render?.({ ...model, estimated_brl: null }),
+    ).toContain("0,00");
+    expect(
+      columns
+        .find((column) => column.key === "tokens")
+        ?.sortValue?.({ ...model, total_tokens: null }),
+    ).toBe(0);
+    expect(
+      columns
+        .find((column) => column.key === "duration")
+        ?.sortValue?.({
+          ...model,
+          duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
+        }),
+    ).toBe(0);
+    expect(
+      columns
+        .find((column) => column.key === "cost")
+        ?.sortValue?.({ ...model, estimated_brl: null }),
+    ).toBe(0);
+  });
   it("keeps a complete observed zero visible without a partial coverage label", () => {
     const observedZeroGroup = {
       ...unavailableGroup,
@@ -649,8 +792,8 @@ describe("grouped cost availability", () => {
     expect(column("contextMultiplier")?.render?.(unavailableRun)).toBe("Indisponível");
     expect(column("inputCost")?.render?.(unavailableRun)).toContain("0,00");
     expect(column("fxRate")?.render?.(unavailableRun)).toBe("R$ 0,00");
-    expect(column("recordedBrl")?.render?.(unavailableRun)).toContain("0,00");
-    expect(column("cost")?.render?.(unavailableRun)).toContain("0,00");
+    expect(column("recordedBrl")?.render?.(unavailableRun)).toBe("Indisponível");
+    expect(column("cost")?.render?.(unavailableRun)).toBe("Indisponível");
   });
   it("provides a clear scroll label for the detailed Runs table", () => {
     expect(costRunsScrollLabel("pt-BR")).toBe(
@@ -727,154 +870,6 @@ describe("grouped cost availability", () => {
     expect(pager.props.pagination.onRetry).toEqual(expect.any(Function));
   });
 });
-describe("manifest-first invocation query", () => {
-  it("opens only intersecting monthly manifests and candidate chunks", async () => {
-    const inRange = signedSummary({
-      agent_invocation_id: "RUN-JULY-OPENAI",
-      occurred_at: "2026-07-10T12:00:00.000Z",
-      provider: "openai",
-    });
-    const outOfRange = signedSummary({
-      agent_invocation_id: "RUN-JULY-ANTHROPIC",
-      occurred_at: "2026-07-20T12:00:00.000Z",
-      provider: "anthropic",
-    });
-    const firstChunk = `${JSON.stringify(inRange)}\n`;
-    const secondChunk = `${JSON.stringify(outOfRange)}\n`;
-    const manifest = signedManifest({
-      period: { year: 2026, month: 7 },
-      from: "2026-07-10T12:00:00.000Z",
-      to: "2026-07-20T12:00:00.000Z",
-      chunks: [
-        {
-          path: ".agents/records/telemetry/2026/07/chunk-openai.jsonl",
-          content_sha256: digest(firstChunk),
-          summary_count: 1,
-          from: inRange.occurred_at,
-          to: inRange.occurred_at,
-          summary_hashes: [inRange.summary_hash],
-          dimensions: dimensions({ providers: ["openai"] }),
-        },
-        {
-          path: ".agents/records/telemetry/2026/07/chunk-anthropic.jsonl",
-          content_sha256: digest(secondChunk),
-          summary_count: 1,
-          from: outOfRange.occurred_at,
-          to: outOfRange.occurred_at,
-          summary_hashes: [outOfRange.summary_hash],
-          dimensions: dimensions({ providers: ["anthropic"] }),
-        },
-      ],
-    });
-    const reads: string[] = [];
-    const openaiChunkPath = manifest.chunks[0]?.path;
-    const anthropicChunkPath = manifest.chunks[1]?.path;
-    if (openaiChunkPath === undefined || anthropicChunkPath === undefined) {
-      throw new Error("Expected two manifest chunks");
-    }
-    const files = new Map<string, string>([
-      [".agents/records/telemetry/2026/07/manifest.json", JSON.stringify(manifest)],
-      [openaiChunkPath, firstChunk],
-      [anthropicChunkPath, secondChunk],
-    ]);
-    const result = await queryInvocationManifestPeriod(
-      {
-        exists: async (path) => files.has(path),
-        readText: async (path) => {
-          reads.push(path);
-          const value = files.get(path);
-          if (value === undefined) throw new Error(`Missing fixture: ${path}`);
-          return value;
-        },
-      },
-      {
-        from: "2026-07-09",
-        to: "2026-07-11",
-        filters: { providers: ["openai"] },
-      },
-    );
-    expect(result.summaries.map((summary) => summary.agent_invocation_id)).toEqual([
-      "RUN-JULY-OPENAI",
-    ]);
-    expect(result.manifest_count).toBe(1);
-    expect(result.chunk_count).toBe(1);
-    expect(result.source_latest_at).toBe("2026-07-20T12:00:00.000Z");
-    expect(result.lag_ms).toBe(10);
-    expect(reads).toEqual([
-      ".agents/records/telemetry/2026/07/manifest.json",
-      ".agents/records/telemetry/2026/07/chunk-openai.jsonl",
-    ]);
-  });
-});
-function digest(value: string): string {
-  return createHash("sha256").update(value).digest("hex");
-}
-function dimensions(overrides: Partial<Record<string, readonly string[]>> = {}) {
-  return {
-    providers: [],
-    models: [],
-    zaip_agents: [],
-    phases: [],
-    purposes: [],
-    statuses: [],
-    executions: [],
-    tasks: [],
-    specs: [],
-    prds: [],
-    changes: [],
-    ...overrides,
-  };
-}
-function signedSummary(input: {
-  agent_invocation_id: string;
-  occurred_at: string;
-  provider: string;
-}) {
-  const unsigned = {
-    schema_version: 1,
-    agent_invocation_id: input.agent_invocation_id,
-    occurred_at: input.occurred_at,
-    coverage: "complete",
-    usage_segments: [{ provider: input.provider, model: "gpt-5.6-terra" }],
-  };
-  return { ...unsigned, summary_hash: digest(JSON.stringify(unsigned)) };
-}
-function signedManifest(input: {
-  period: { year: number; month: number };
-  from: string;
-  to: string;
-  chunks: Array<{
-    path: string;
-    content_sha256: string;
-    summary_count: number;
-    from: string;
-    to: string;
-    summary_hashes: string[];
-    dimensions: ReturnType<typeof dimensions>;
-  }>;
-}) {
-  const unsigned = {
-    schema_version: 1,
-    period: input.period,
-    summary_count: input.chunks.reduce((sum, chunk) => sum + chunk.summary_count, 0),
-    chunk_count: input.chunks.length,
-    from: input.from,
-    to: input.to,
-    source_latest_at: input.to,
-    lag_ms: 10,
-    coverage: { complete: 2, partial: 0, unavailable: 0 },
-    chunks: input.chunks,
-    dimensions: dimensions(),
-    aggregates: { daily: {}, monthly: {}, annual: {} },
-    integrity: {
-      status: "verified",
-      algorithm: "sha256",
-      chunk_count: input.chunks.length,
-      summary_count: input.chunks.reduce((sum, chunk) => sum + chunk.summary_count, 0),
-    },
-  };
-  return { ...unsigned, manifest_hash: digest(JSON.stringify(unsigned)) };
-}
 describe("cost sorting", () => {
   it("orders the raw BRL values rather than their localized currency labels", () => {
     const rows = [143.72, 127.78, 21457.76, 1370.63];