@zaip-ai/cli 1.0.4 → 1.0.7

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

@@ -0,0 +1,708 @@
+import { createHash } from "node:crypto";
+import { queryInvocationManifestPeriod } from "@zaip-ai/costs";
+import { describe, expect, it } from "vitest";
+import {
+  activeCostPeriodData,
+  costPeriodDateRange,
+  defaultCostPeriod,
+  loadCostMonitorPeriod,
+  shouldFetchCostPeriod,
+} from "./CostFilters.js";
+import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
+import {
+  agentRunModelPresentation,
+  CostGroupsTable,
+  CostRunsTable,
+  contextUpliftUsd,
+  costGroupsScrollLabel,
+  costPeriodTotalAriaLabel,
+  costRunsDurationTotal,
+  costRunsScrollLabel,
+  formatAuditableCompactNumber,
+  formatAuditableCurrency,
+  formatAuditableDuration,
+  formatAuditableNumber,
+  formatBrlRate,
+  formatCostPeriodLabel,
+  formatDateTime,
+  formatDurationCoverage,
+  formatMultiplierPair,
+  formatRate,
+  formatReasoningEffort,
+  formatServiceTier,
+  formatUsd,
+  hasCollectedUsage,
+  isCompactRunColumnVisible,
+  isDisplayableModel,
+  ratio,
+  runOriginBadge,
+  sortCostValue,
+} from "./CostTables.js";
+
+describe("Agent Run model presentation", () => {
+  it("shows only the effective model and its provider", () => {
+    expect(
+      agentRunModelPresentation({
+        requested_model: "gpt-5.6-terra",
+        model: "gpt-5.6-sol",
+        provider: "openai",
+      }),
+    ).toEqual({ primary: "gpt-5.6-sol", detail: "openai" });
+  });
+
+  it("does not mention an unavailable planned configuration", () => {
+    expect(
+      agentRunModelPresentation({
+        requested_model: "unknown",
+        model: "gpt-5.6-sol",
+        provider: "openai",
+      }),
+    ).toEqual({
+      primary: "gpt-5.6-sol",
+      detail: "openai",
+    });
+  });
+});
+
+describe("period formatting", () => {
+  it("renders daily dates and keeps monthly periods numerically sortable", () => {
+    expect(formatCostPeriodLabel("2026-07-16", "daily", "pt-BR")).toBe("16/07/2026");
+    expect(formatCostPeriodLabel("2026-07", "monthly", "pt-BR")).toBe("2026-07");
+    expect(formatCostPeriodLabel("2025-12", "monthly", "en-US")).toBe("2025-12");
+    expect(formatCostPeriodLabel("2026", "annual", "pt-BR")).toBe("2026");
+  });
+});
+
+describe("period total accessibility", () => {
+  it("names the complete period total with the displayed time, tokens, and BRL values", () => {
+    expect(
+      costPeriodTotalAriaLabel({
+        locale: "pt-BR",
+        duration: "2h 15min",
+        tokens: "1,2 mi",
+        cost: "R$ 3,40",
+        currency: "BRL",
+      }),
+    ).toBe("Total geral — Tempo: 2h 15min; Tokens: 1,2 mi; BRL: R$ 3,40");
+  });
+});
+
+describe("Run origin badges", () => {
+  it("uses one hierarchical origin per Run", () => {
+    expect(runOriginBadge({ prd_id: "PRD-1", spec_id: "SPEC-1", task_id: "TASK-1" })).toEqual({
+      label: "PRD",
+      tone: "prd",
+    });
+    expect(runOriginBadge({ prd_id: null, spec_id: "SPEC-1", task_id: "TASK-1" })).toEqual({
+      label: "SPEC",
+      tone: "spec",
+    });
+    expect(runOriginBadge({ prd_id: null, spec_id: null, task_id: "TASK-1" })).toEqual({
+      label: "Tarefa avulsa",
+      tone: "task",
+    });
+  });
+});
+
+describe("date time formatting", () => {
+  it("uses a placeholder for groups that do not yet have a Run", () => {
+    expect(formatDateTime("", "pt-BR")).toBe("—");
+  });
+});
+
+describe("formatAuditableNumber", () => {
+  it("keeps unavailable numeric metrics distinct from observed zero", () => {
+    expect(formatAuditableNumber(null, "pt-BR")).toBe("Indisponível");
+    expect(formatAuditableNumber(null, "en-US")).toBe("Unavailable");
+    expect(formatAuditableNumber(0, "pt-BR")).toBe("0");
+  });
+
+  it("keeps observed positive values", () => {
+    expect(formatAuditableNumber(1234, "pt-BR")).toBe("1.234");
+  });
+});
+
+describe("compact Sub-Run columns", () => {
+  it("keeps a column hidden until at least one Sub-Run has observed data", () => {
+    const rows = [{ duration_ms: null }, { duration_ms: null }] as never;
+    expect(isCompactRunColumnVisible(rows, (row) => row.duration_ms)).toBe(false);
+    expect(
+      isCompactRunColumnVisible(
+        [{ duration_ms: null }, { duration_ms: 2 }] as never,
+        (row) => row.duration_ms,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("monetary formatting", () => {
+  it("uses exactly two decimal places for rates and USD totals", () => {
+    expect(formatRate(5.450000053204, "pt-BR")).toBe("5,45");
+    expect(formatBrlRate(5.450000053204, "pt-BR")).toBe("R$ 5,45");
+    expect(formatUsd(19.583447, "pt-BR").replace(/\s/g, " ")).toBe("US$ 19,58");
+  });
+
+  it("calculates exchange as a direct BRL/USD ratio", () => {
+    expect(ratio(106.73, 19.583444)).toBeCloseTo(5.45, 2);
+    expect(ratio(100, 0)).toBeNull();
+  });
+
+  it("keeps unavailable duration distinct from an observed zero", () => {
+    expect(formatRate(null, "pt-BR")).toBe("Indisponível");
+    expect(formatUsd(null, "en-US")).toBe("Unavailable");
+    expect(formatAuditableCurrency(null, "BRL", "pt-BR")).toBe("Indisponível");
+    expect(formatAuditableDuration(null, "pt-BR")).toBe("Indisponível");
+    expect(formatAuditableCompactNumber(null, "pt-BR")).toBe("Indisponível");
+    expect(formatMultiplierPair(null, null, "pt-BR")).toBe("Indisponível");
+    expect(formatMultiplierPair(2, null, "pt-BR")).toBe("Indisponível");
+  });
+});
+
+describe("duration coverage", () => {
+  it("renders known partial duration without claiming it is complete", () => {
+    expect(
+      formatDurationCoverage(
+        { known_sum: 60_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
+        "pt-BR",
+      ),
+    ).toBe("1 min");
+    expect(
+      formatDurationCoverage(
+        { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+        "pt-BR",
+      ),
+    ).toBe("Indisponível");
+  });
+});
+
+describe("runtime availability", () => {
+  it("uses requested effort only as a clearly labelled visual fallback", () => {
+    expect(formatReasoningEffort("high", "medium", "pt-BR")).toBe("Alto");
+    expect(formatReasoningEffort(null, "high", "pt-BR")).toBe("Alto (solicitado; efetivo -)");
+    expect(formatReasoningEffort(null, null, "en-US")).toBe("-");
+  });
+
+  it("uses the default speed label when the service tier is unavailable", () => {
+    expect(formatServiceTier(null, "pt-BR")).toBe("Padrão");
+    expect(formatServiceTier("unknown", "pt-BR")).toBe("Padrão");
+    expect(formatServiceTier(null, "en-US")).toBe("Standard");
+    expect(formatServiceTier("priority", "pt-BR")).toBe("Rápido");
+  });
+});
+
+describe("grouped cost availability", () => {
+  it("uses deduplicated root and child invocation effort in the Run drilldown footer", () => {
+    const root = {
+      run_id: "RUN-ROOT",
+      phase: "execution",
+      parent_run_id: null,
+      duration_ms: 2_000,
+    } as never;
+    const child = {
+      run_id: "RUN-CHILD",
+      phase: "execution",
+      parent_run_id: "RUN-ROOT",
+      duration_ms: 9_000,
+    } as never;
+    expect(costRunsDurationTotal([root, child, child])).toBe(11_000);
+  });
+  const unavailableGroup = {
+    key: "unknown",
+    label: "Sem telemetria",
+    latest_started_at: "2026-07-24T20:00:00.000Z",
+    run_count: 2,
+    task_count: 1,
+    prd_count: 0,
+    spec_count: 0,
+    evidence_count: 0,
+    test_count: 0,
+    event_count: 2,
+    total_tokens: null,
+    estimated_usd: null,
+    estimated_brl: null,
+    duration_ms: null,
+    duration: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+    coverage: { events: 2, tokens: 0, usd: 0, brl: 0 },
+  } as const;
+
+  it("renders unavailable duration explicitly and keeps the accessible scroll region", () => {
+    const table = CostGroupsTable({
+      rows: [unavailableGroup],
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      render: (row: typeof unavailableGroup) => unknown;
+      sortValue?: (row: typeof unavailableGroup) => unknown;
+      footer?: unknown;
+    }>;
+    const column = (key: string) => columns.find((candidate) => candidate.key === key);
+
+    expect(table.props.scrollLabel).toBe(costGroupsScrollLabel("pt-BR"));
+    expect(column("duration")?.render(unavailableGroup)).toBe("Indisponível");
+    expect(column("tokens")?.render(unavailableGroup)).toBe("Indisponível");
+    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\u00edvel; Tokens: Indispon\u00edvel; BRL: Indispon\u00edvel";
+    expect(
+      (column("latestStartedAt")!.footer as { props: { "aria-label": string } }).props[
+        "aria-label"
+      ],
+    ).toBe("Total geral");
+    expect(
+      (column("duration")!.footer as { props: { "aria-label": string } }).props["aria-label"],
+    ).toBe(totalSummary);
+    expect(
+      (column("tokens")!.footer as { props: { "aria-label": string } }).props["aria-label"],
+    ).toBe(totalSummary);
+    expect(
+      (column("cost")!.footer as { props: { "aria-label": string } }).props["aria-label"],
+    ).toBe(totalSummary);
+    expect(column("coverage")).toBeUndefined();
+  });
+
+  it("keeps a complete observed zero visible without a partial coverage label", () => {
+    const observedZeroGroup = {
+      ...unavailableGroup,
+      duration_ms: 0,
+      duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    const table = CostGroupsTable({ rows: [observedZeroGroup], currency: "BRL", locale: "pt-BR" });
+    const duration = (
+      table.props.columns as Array<{
+        key: string;
+        render: (row: typeof observedZeroGroup) => unknown;
+        footer?: { props: { children: unknown } };
+      }>
+    ).find((column) => column.key === "duration");
+
+    expect(duration?.render(observedZeroGroup)).toBe(formatAuditableDuration(0, "pt-BR"));
+    expect(duration?.footer?.props.children).toBe(formatAuditableDuration(0, "pt-BR"));
+  });
+
+  it("does not expose coverage as a detailed Run column", () => {
+    const table = CostRunsTable({
+      rows: [unavailableGroup] as never,
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const columns = table.props.columns as Array<{ key: string }>;
+    expect(columns.some((column) => column.key === "coverage")).toBe(false);
+  });
+
+  it("sorts unavailable Run numeric metrics as unavailable", () => {
+    const unavailableRun = { ...unavailableGroup, input_tokens: null, output_tokens: null };
+    const table = CostRunsTable({
+      rows: [unavailableRun] as never,
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      sortValue?: (row: typeof unavailableGroup) => unknown;
+    }>;
+    const column = (key: string) => columns.find((candidate) => candidate.key === key);
+
+    expect(column("duration")?.sortValue?.(unavailableRun)).toBeNull();
+    expect(column("totalTokens")?.sortValue?.(unavailableRun)).toBeNull();
+    expect(column("cost")?.sortValue?.(unavailableRun)).toBeNull();
+  });
+
+  it("provides a clear scroll label for the detailed Runs table", () => {
+    expect(costRunsScrollLabel("pt-BR")).toBe(
+      "Tabela de custos por invocação com rolagem horizontal",
+    );
+  });
+});
+
+describe("period-driven Cost Monitor loading", () => {
+  it("drops a stale in-memory Cost period response when refresh replaces its base snapshot", () => {
+    const stale = { runs: [{ run_id: "RUN-OBSERVED", duration_ms: 31 * 3_600_000 }] } as never;
+    const refreshed = { runs: [{ run_id: "RUN-PROJECTED", duration_ms: 413_659_026 }] } as never;
+
+    expect(activeCostPeriodData(refreshed, stale, stale)).toBe(refreshed);
+    expect(activeCostPeriodData(refreshed, refreshed, refreshed)).toBe(refreshed);
+  });
+
+  it("does not issue a second Cost request after an embedded default atomic snapshot", () => {
+    const filters = {
+      query: "",
+      provider: "",
+      phase: "",
+      origin: "",
+      workType: "",
+      agent: "",
+      model: "",
+      status: "",
+      priority: "",
+      risk: "",
+    };
+    expect(shouldFetchCostPeriod({ filters, period: "all", snapshotBacked: true })).toBe(false);
+    expect(shouldFetchCostPeriod({ filters, period: "7", snapshotBacked: true })).toBe(true);
+    expect(
+      shouldFetchCostPeriod({
+        filters: { ...filters, phase: "execution" },
+        period: "all",
+        snapshotBacked: true,
+      }),
+    ).toBe(true);
+  });
+
+  it("uses no date bounds for the default complete-history period", async () => {
+    expect(defaultCostPeriod).toBe("all");
+    expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
+    expect(costPeriodDateRange("month", new Date("2026-08-01T03:30:00.000Z"))).toEqual({
+      from: "2026-08-01",
+      to: "2026-08-01",
+    });
+    // Resetting standalone Cost Monitor to All Time removes the prior month
+    // bounds instead of carrying them into the next request.
+    expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
+    const calls: string[] = [];
+    await loadCostMonitorPeriod({
+      currency: "BRL",
+      fetcher: async (url) => {
+        calls.push(String(url));
+        return new Response(JSON.stringify({ runs: [] }), { status: 200 });
+      },
+    });
+    expect(calls).toEqual(["/api/v2/cost-monitor?currency=BRL"]);
+  });
+
+  it("derives an inclusive current-month range without inspecting materialized Runs", () => {
+    expect(costPeriodDateRange("month", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
+      from: "2026-07-01",
+      to: "2026-07-26",
+    });
+    expect(costPeriodDateRange("7", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
+      from: "2026-07-20",
+      to: "2026-07-26",
+    });
+  });
+
+  it("requests the selected range from the local runtime and forwards cancellation", async () => {
+    const calls: Array<{ url: string; signal: AbortSignal | null | undefined }> = [];
+    const controller = new AbortController();
+    const projection = { runs: [] };
+    const loaded = await loadCostMonitorPeriod({
+      currency: "BRL",
+      from: "2026-07-01",
+      to: "2026-07-26",
+      filters: {
+        query: "TASK-1",
+        provider: "openai",
+        phase: "execution",
+        origin: "spec",
+        workType: "rework",
+        agent: "zaip-agent-builder",
+        model: "gpt-5.6-terra",
+        status: "completed",
+        priority: "high",
+        risk: "standard",
+      },
+      signal: controller.signal,
+      fetcher: async (url, init) => {
+        calls.push({ url: String(url), signal: init?.signal });
+        return new Response(JSON.stringify(projection), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        });
+      },
+    });
+
+    expect(loaded).toEqual(projection);
+    expect(calls).toEqual([
+      {
+        url:
+          "/api/v2/cost-monitor?currency=BRL&from=2026-07-01&to=2026-07-26" +
+          "&provider=openai&phase=execution&agent=zaip-agent-builder" +
+          "&model=gpt-5.6-terra&status=completed",
+        signal: controller.signal,
+      },
+    ]);
+  });
+});
+
+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];
+
+    expect(
+      rows.sort(
+        (left, right) =>
+          (sortCostValue("BRL", right, null) ?? 0) - (sortCostValue("BRL", left, null) ?? 0),
+      ),
+    ).toEqual([21457.76, 1370.63, 143.72, 127.78]);
+  });
+});
+
+describe("context uplift", () => {
+  const base = {
+    context_input_multiplier: 1,
+    context_output_multiplier: 1,
+    input_cost_usd: 10,
+    cached_input_cost_usd: 2,
+    output_cost_usd: 8,
+    reasoning_cost_usd: 2,
+  };
+
+  it("returns zero for a 1x / 1x call", () => {
+    expect(contextUpliftUsd(base as never)).toBe(0);
+  });
+
+  it("extracts the already included context portion from effective costs", () => {
+    expect(
+      contextUpliftUsd({
+        ...base,
+        context_input_multiplier: 2,
+        context_output_multiplier: 1.5,
+      } as never),
+    ).toBeCloseTo(9.333333, 5);
+  });
+});
+
+describe("model aggregation visibility", () => {
+  it("hides the manual placeholder regardless of casing or whitespace", () => {
+    expect(isDisplayableModel("manual")).toBe(false);
+    expect(isDisplayableModel(" Manual ")).toBe(false);
+    expect(isDisplayableModel("unknown")).toBe(false);
+    expect(isDisplayableModel(" ")).toBe(false);
+    expect(isDisplayableModel("gpt-5")).toBe(false);
+    expect(isDisplayableModel(" GPT-5 ")).toBe(false);
+    expect(isDisplayableModel("gpt-5.4")).toBe(true);
+    expect(isDisplayableModel("gpt-5.6-sol")).toBe(true);
+  });
+
+  it("hides calls that have no collected usage", () => {
+    const empty = {
+      input_tokens: null,
+      cached_input_tokens: null,
+      output_tokens: null,
+      reasoning_tokens: null,
+      total_tokens: null,
+      estimated_usd: null,
+      estimated_brl: null,
+    };
+    expect(hasCollectedUsage(empty as never)).toBe(false);
+    expect(hasCollectedUsage({ ...empty, input_tokens: 1 } as never)).toBe(true);
+    expect(hasCollectedUsage({ ...empty, estimated_brl: 0.01 } as never)).toBe(true);
+  });
+});
+
+describe("model processing duration", () => {
+  it("sums root orchestration Runs without overlapping intake and Sub-Runs", () => {
+    expect(
+      sumModelDurationMs([
+        { duration_ms: 60_000, run_kind: "run", run_purpose: "orchestration" },
+        { duration_ms: 90_000, run_kind: "subrun", run_purpose: "execution" },
+        { duration_ms: 120_000, run_kind: "run", run_purpose: "intake" },
+        { duration_ms: 30_000, run_kind: "run", run_purpose: "orchestration" },
+      ]),
+    ).toBe(300_000);
+    expect(
+      sumModelDurationMs([
+        { duration_ms: 90_000, run_kind: "subrun", run_purpose: "execution" },
+        { duration_ms: 120_000, run_kind: "run", run_purpose: "intake" },
+      ]),
+    ).toBe(210_000);
+  });
+
+  it("groups Runs without an identifiable model as Undefined", () => {
+    expect(displayModelName("gpt-5.6-sol", "pt-BR")).toBe("gpt-5.6-sol");
+    expect(displayModelName("unknown", "pt-BR")).toBe("Indefinido");
+    expect(displayModelName(" ", "en-US")).toBe("Undefined");
+    expect(displayModelName("manual", "pt-BR")).toBeNull();
+    expect(displayModelName("gpt-5", "pt-BR")).toBeNull();
+  });
+
+  it("keeps duration-only root orchestration Runs in the model table", () => {
+    expect(
+      isModelAuditRow({
+        duration_ms: 90_000,
+        run_kind: "run",
+        run_purpose: "orchestration",
+        input_tokens: null,
+        cached_input_tokens: null,
+        output_tokens: null,
+        reasoning_tokens: null,
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      } as never),
+    ).toBe(true);
+    expect(
+      isModelAuditRow({
+        duration_ms: 90_000,
+        run_kind: "subrun",
+        run_purpose: "execution",
+        input_tokens: null,
+        cached_input_tokens: null,
+        output_tokens: null,
+        reasoning_tokens: null,
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      } as never),
+    ).toBe(true);
+  });
+});