@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -32,6 +32,23 @@ describe("macroCostDuration", () => {
     expect(operationalMacroDuration({ duration_ms: 2_686_869 } as never)).toBeNull();
   });
 
+  it("accepts factual values and estimates a tokenized Run without lifecycle elapsed time", () => {
+    expect(
+      macroCostDuration({
+        source_duration_ms: null,
+        duration_ms: 2_105_284,
+        duration_provenance: "legacy_inferred",
+      } as never),
+    ).toBe(2_105_284);
+    expect(
+      macroCostDuration({
+        source_duration_ms: null,
+        duration_ms: null,
+        usage: { total: { tokens: { total: 4_000_000 } } },
+      } as never),
+    ).toBe(3_600_000);
+  });
+
   it("uses only the root execution analytical duration, never lifecycle elapsed time or a subrun", () => {
     const macro = { id: "PRD-1", kind: "prd", run_ids: [] } as never;
     const root = {

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

@@ -11,6 +11,7 @@ import {
   formatPercent,
 } from "@zaip-ai/dashboard-ui";
 import { useState } from "react";
+import { estimatedDurationMs } from "../duration-estimate.js";
 import { formatDateTime, sortCostValue } from "./CostTables.js";
 import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
 
@@ -19,19 +20,23 @@ export function MacroCostTable({
   currency,
   details,
   locale,
+  totalDurationMs,
   onOpenTrace,
 }: {
   rows: readonly MacroProjection[];
   currency: CostCurrency;
   details?: Pick<OperationsProjection, "runs" | "specs" | "tasks">;
   locale: CostLocale;
+  totalDurationMs?: number | null;
   onOpenTrace: (taskId: string) => void;
 }) {
   const [selectedRow, setSelectedRow] = useState<MacroProjection | null>(null);
   const openRow = (row: MacroProjection) => setSelectedRow(row);
   const totalTasks = rows.reduce((sum, row) => sum + row.task_count, 0);
   const totalRuns = rows.reduce((sum, row) => sum + row.run_count, 0);
-  const durations = rows.map((row) => operationalMacroDuration(row, details?.runs ?? []));
+  const durations = rows.map(
+    (row) => row.duration_ms ?? operationalMacroDuration(row, details?.runs ?? []),
+  );
   const totalDuration = sumObserved(durations);
   const totalTokens = rows.reduce((sum, row) => sum + (row.usage.total.tokens.total ?? 0), 0);
   const totalCost = rows.reduce(
@@ -79,12 +84,17 @@ export function MacroCostTable({
             key: "duration",
             label: locale === "pt-BR" ? "Tempo" : "Time",
             render: (row) => {
-              const duration = operationalMacroDuration(row, details?.runs ?? []);
-              return duration === null ? "Indisponível" : formatDurationMs(duration, locale);
+              const duration =
+                row.duration_ms ?? operationalMacroDuration(row, details?.runs ?? []);
+              return duration === null || duration === 0 ? "0" : formatDurationMs(duration, locale);
             },
             align: "right",
             footer:
-              totalDuration === null ? "Indisponível" : formatDurationMs(totalDuration, locale),
+              totalDurationMs !== null && totalDurationMs !== undefined
+                ? formatDurationMs(totalDurationMs, locale)
+                : totalDuration === null || totalDuration === 0
+                  ? "0"
+                  : formatDurationMs(totalDuration, locale),
           },
           {
             key: "tokens",
@@ -183,9 +193,18 @@ export function operationalMacroDuration(
 }
 
 export function macroCostDuration(
-  run: Pick<OperationsProjection["runs"][number], "source_duration_ms">,
+  run: Pick<
+    OperationsProjection["runs"][number],
+    "source_duration_ms" | "duration_ms" | "duration_provenance" | "usage"
+  >,
 ): number | null {
-  return typeof run.source_duration_ms === "number" ? run.source_duration_ms : null;
+  if (typeof run.source_duration_ms === "number") return run.source_duration_ms;
+  if (
+    (run.duration_provenance === "legacy_inferred" || run.duration_provenance === "reconciled") &&
+    typeof run.duration_ms === "number"
+  )
+    return run.duration_ms;
+  return estimatedDurationMs(run.usage?.total.tokens.total ?? null);
 }
 
 export function macroCoverageProvenanceLabel(

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

@@ -22,7 +22,6 @@ export const costCopy = {
     last30: "Últimos 30 dias",
     last90: "Últimos 90 dias",
     thisMonth: "Este mês",
-    observed: "cobertura observada",
     noData: "Sem dados no filtro atual.",
     tabs: {
       overview: "Visão geral",
@@ -59,7 +58,6 @@ export const costCopy = {
     last30: "Last 30 days",
     last90: "Last 90 days",
     thisMonth: "This month",
-    observed: "observed coverage",
     noData: "No data for the current filter.",
     tabs: {
       overview: "Overview",

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

@@ -0,0 +1,17 @@
+export function findRunDetails<T extends { id: string }>(
+  runs: readonly T[],
+  runId: string,
+): T | null {
+  return runs.find((run) => run.id === runId) ?? null;
+}
+
+export function isCurrentCostRunPageGeneration(request: number, current: number): boolean {
+  return request === current;
+}
+
+export function selectDimensionalCostRows<T>(
+  summaryRows: readonly T[],
+  detailRows: readonly T[] | undefined,
+): readonly T[] {
+  return detailRows ?? summaryRows;
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-monitor-responsive.css

@@ -102,6 +102,12 @@
     align-items: stretch;
     flex-direction: column;
   }
+  .cost-tabs-bar {
+    grid-template-columns: 1fr;
+  }
+  .cost-tab-export {
+    justify-content: flex-end;
+  }
 }
 
 @media (max-width: 500px) {
@@ -117,7 +123,4 @@
   .cost-nav-actions button {
     grid-column: span 2;
   }
-  .cost-coverage-note {
-    flex-direction: column;
-  }
 }

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-monitor-row-filters.ts

@@ -0,0 +1,123 @@
+import { saoPauloPeriodKey } from "@zaip-ai/dashboard-operations/contracts";
+import {
+  aggregateDurationCoverage,
+  type CostGroupRow,
+  type CostRunRow,
+  sumKnown,
+} from "../contracts.js";
+import { normalizeCostProvider } from "../provider.js";
+import type { CostFilterState } from "./CostFilters.js";
+import { durationContributors } from "./cost-duration.js";
+
+export function matches(row: CostRunRow, filter: CostFilterState): boolean {
+  const query = filter.query.trim().toLowerCase();
+  return (
+    (!query ||
+      [row.run_id, row.task_title, row.model, row.requested_model, row.agent, row.agent_name].some(
+        (value) => value.toLowerCase().includes(query),
+      )) &&
+    (!filter.provider || normalizeCostProvider(row.provider) === filter.provider) &&
+    (!filter.agent || row.agent_name === filter.agent) &&
+    (!filter.model || row.model === filter.model) &&
+    (!filter.status || row.task_status === filter.status) &&
+    (!filter.priority || row.priority === filter.priority) &&
+    (!filter.risk || row.risk === filter.risk) &&
+    (!filter.phase || row.phase === filter.phase) &&
+    (!filter.origin || row.origin === filter.origin) &&
+    (!filter.workType || row.work_type === filter.workType)
+  );
+}
+
+export function matchesGlobalFilters(
+  row: CostRunRow,
+  filters: { query: string; dateRange?: { start: string; end: string } } | undefined,
+): boolean {
+  if (!filters) return true;
+  const query = filters.query.trim().toLocaleLowerCase();
+  const matchesQuery =
+    !query ||
+    [
+      row.run_id,
+      row.task_id,
+      row.task_title,
+      row.provider,
+      row.agent,
+      row.agent_name,
+      row.model,
+      row.requested_model,
+      row.phase,
+    ].some((value) => value?.toLocaleLowerCase().includes(query));
+  if (filters.dateRange === undefined) return matchesQuery;
+  const startedDate = saoPauloPeriodKey(row.started_at, "day") ?? row.started_at.slice(0, 10);
+  return (
+    startedDate >= filters.dateRange.start && startedDate <= filters.dateRange.end && matchesQuery
+  );
+}
+
+export function groupRows(
+  rows: readonly CostRunRow[],
+  select: (row: CostRunRow) => string,
+  label: (row: CostRunRow) => string = select,
+  durationScope: "root_execution" | "all_execution" | "all_invocations" = "all_invocations",
+): CostGroupRow[] {
+  const contributors = durationContributors(rows, durationScope);
+  const groups = new Map<string, CostRunRow[]>();
+  for (const row of rows) groups.set(select(row), [...(groups.get(select(row)) ?? []), row]);
+  return [...groups]
+    .map(([key, items]) => {
+      const duration = aggregateDurationCoverage(
+        contributors.filter((candidate) => items.includes(candidate)),
+        durationScope === "all_execution" ? "all_execution" : "all_invocations",
+      );
+      const taskCount = new Set(items.flatMap((row) => (row.task_id ? [row.task_id] : []))).size;
+      return {
+        duration_ms: duration.complete ? duration.known_sum : null,
+        duration,
+        key,
+        label: label(items[0] as CostRunRow),
+        latest_started_at: items.reduce(
+          (latest, row) => (row.started_at > latest ? row.started_at : latest),
+          items[0]?.started_at ?? "",
+        ),
+        run_count: items.length,
+        task_count: taskCount,
+        tasksActive: taskCount,
+        taskDaysActive: taskCount,
+        prd_count: 0,
+        spec_count: 0,
+        evidence_count: 0,
+        test_count: 0,
+        event_count: items.reduce((sum, row) => sum + (row.event_count ?? 0), 0),
+        total_tokens: sumKnown(items.map((row) => row.total_tokens)),
+        estimated_usd: sumKnown(items.map((row) => row.estimated_usd)),
+        estimated_brl: sumKnown(items.map((row) => row.estimated_brl)),
+        coverage: items.reduce(
+          (sum, row) => ({
+            events: sum.events + row.coverage.events,
+            tokens: sum.tokens + row.coverage.tokens,
+            usd: sum.usd + row.coverage.usd,
+            brl: sum.brl + row.coverage.brl,
+          }),
+          { events: 0, tokens: 0, usd: 0, brl: 0 },
+        ),
+      };
+    })
+    .sort((a, b) => b.latest_started_at.localeCompare(a.latest_started_at));
+}
+
+export function matchesPeriodEntity(
+  entity: { id?: string; title?: string; created_at: string | null },
+  filters: { query: string; dateRange?: { start: string; end: string } } | undefined,
+): boolean {
+  if (filters === undefined) return true;
+  const query = filters.query.trim().toLowerCase();
+  if (
+    query &&
+    ![entity.id ?? "", entity.title ?? ""].some((value) => value.toLowerCase().includes(query))
+  )
+    return false;
+  if (filters.dateRange === undefined) return true;
+  if (entity.created_at === null) return false;
+  const date = saoPauloPeriodKey(entity.created_at, "day") ?? entity.created_at.slice(0, 10);
+  return date >= filters.dateRange.start && date <= filters.dateRange.end;
+}

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

@@ -17,10 +17,12 @@ export function applyLegacyPeriodGroups(
   rows: readonly CostRunRow[],
   granularity: "day" | "month" | "year",
   legacy: { cutoff: string; duration_ms: number } | null,
+  range?: { start: string; end: string },
 ): CostGroupRow[] {
   if (legacy === null) return groups;
   const byKey = new Map(groups.map((group) => [group.key, group]));
   for (const day of Object.keys(LEGACY_EFFORT_DAILY_MS)) {
+    if (range !== undefined && (day < range.start || day > range.end)) continue;
     const key = saoPauloPeriodKey(`${day}T12:00:00.000Z`, granularity);
     if (key !== null && !byKey.has(key))
       byKey.set(key, {
@@ -55,7 +57,10 @@ export function applyLegacyPeriodGroups(
       const duration = aggregateDurationCoverage(post, "all_invocations");
       const legacyDuration = Object.entries(LEGACY_EFFORT_DAILY_MS).reduce(
         (sum, [day, value]) =>
-          saoPauloPeriodKey(`${day}T12:00:00.000Z`, granularity) === group.key ? sum + value : sum,
+          (range === undefined || (day >= range.start && day <= range.end)) &&
+          saoPauloPeriodKey(`${day}T12:00:00.000Z`, granularity) === group.key
+            ? sum + value
+            : sum,
         0,
       );
       const known_sum = duration.known_sum + legacyDuration;
@@ -101,7 +106,7 @@ export function summarizeCostRows(
   );
   const knownRows = rows.filter((row) => row.total_tokens !== null);
   const knownTokens = knownRows.reduce((sum, row) => sum + (row.total_tokens ?? 0), 0);
-  const knownCycles = knownRows.reduce((sum, row) => sum + row.event_count, 0);
+  const knownCycles = knownRows.reduce((sum, row) => sum + (row.event_count ?? 0), 0);
   const top10Tokens = [...knownRows]
     .sort((left, right) => (right.total_tokens ?? 0) - (left.total_tokens ?? 0))
     .slice(0, 10)
@@ -109,7 +114,7 @@ export function summarizeCostRows(
   return {
     task_count: new Set(rows.flatMap((row) => (row.task_id ? [row.task_id] : []))).size,
     run_count: rows.length,
-    event_count: rows.reduce((sum, row) => sum + row.event_count, 0),
+    event_count: rows.reduce((sum, row) => sum + (row.event_count ?? 0), 0),
     total_tokens: sumKnown(rows.map((row) => row.total_tokens)),
     estimated_usd: sumKnown(rows.map((row) => row.estimated_usd)),
     estimated_brl: sumKnown(rows.map((row) => row.estimated_brl)),

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

@@ -0,0 +1,32 @@
+export type CostView =
+  | "overview"
+  | "agentCalls"
+  | "executions"
+  | "conversations"
+  | "tasks"
+  | "prds"
+  | "specs"
+  | "providers"
+  | "agents"
+  | "models"
+  | "daily"
+  | "monthly"
+  | "annual";
+
+export const DEFAULT_COST_VIEW: CostView = "daily";
+
+export const COST_VIEW_ORDER: readonly CostView[] = [
+  "daily",
+  "monthly",
+  "annual",
+  "overview",
+  "executions",
+  "agentCalls",
+  "agents",
+  "models",
+  "providers",
+  "tasks",
+  "specs",
+  "prds",
+  "conversations",
+];

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

@@ -237,6 +237,20 @@
   min-width: 0;
   table-layout: fixed;
 }
+.cost-content:is(.cost-content-daily, .cost-content-monthly, .cost-content-annual) .cost-page-controls {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+  margin-top: 12px;
+}
+.cost-content:is(.cost-content-daily, .cost-content-monthly, .cost-content-annual) .cost-page-controls output {
+  min-width: 8.5rem;
+  color: var(--muted);
+  font-size: 0.78rem;
+  text-align: center;
+  font-variant-numeric: tabular-nums;
+}
 .cost-content:is(.cost-content-daily, .cost-content-monthly, .cost-content-annual)
   .ui-table-heading {
   width: 100%;
@@ -398,18 +412,6 @@
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-.cost-coverage-note {
-  display: flex;
-  justify-content: space-between;
-  gap: 16px;
-  margin: 12px 2px 0;
-  color: #8295ad;
-  font-size: 0.72rem;
-}
-.cost-coverage-note span {
-  color: #00b0f0;
-  font-family: ui-monospace, SFMono-Regular, Consolas, monospace;
-}
 .cost-filters {
   display: grid;
   grid-template-columns: minmax(220px, 2fr) repeat(5, minmax(120px, 1fr));
@@ -441,16 +443,23 @@
 .cost-filters > button {
   align-self: end;
 }
+.cost-tabs-bar {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: start;
+  gap: 12px;
+  padding: 2px 2px 12px;
+}
 .cost-tabs {
   display: flex;
   flex-wrap: wrap;
   gap: 6px;
   overflow-x: visible;
-  padding: 2px 2px 12px;
 }
 .cost-tabs button {
   flex: 0 0 auto;
-  min-height: 40px;
+  min-height: 44px;
+  border-radius: 999px;
   padding-inline: 10px;
   font-size: 0.82rem;
 }
@@ -459,6 +468,35 @@
   background: var(--accent-soft);
   color: var(--accent);
 }
+.cost-tab-export {
+  display: flex;
+  justify-content: flex-end;
+}
+.cost-tab-export .excel-export-action {
+  min-height: 44px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  gap: 6px;
+  padding: 0 10px;
+  background: linear-gradient(135deg, #00b0f0 0%, #72f4fb 100%);
+  color: #042330;
+  font-size: 0.82rem;
+  font-weight: 650;
+}
+.cost-tab-export .excel-export-action svg {
+  width: 14px;
+  height: 14px;
+}
+.cost-tab-export .excel-export-action:hover:not(:disabled) {
+  border-color: rgba(114, 244, 251, 0.72);
+  background: linear-gradient(135deg, #00b0f0 0%, #72f4fb 100%);
+  color: #042330;
+}
+.cost-tabs button:focus-visible,
+.cost-tab-export .excel-export-action:focus-visible {
+  outline: 3px solid #00b0f0;
+  outline-offset: 2px;
+}
 .cost-run-kind-toolbar {
   display: flex;
   gap: 8px;

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-table-presentation.ts

@@ -0,0 +1,121 @@
+import type { CostRunRow } from "../contracts.js";
+import { durationContributors } from "./cost-duration.js";
+import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
+import { sumNumbers } from "./cost-table-metrics.js";
+
+export const costRunsDurationTotal = (rows: readonly CostRunRow[]) =>
+  sumNumbers(durationContributors(rows).map((row) => row.duration_ms));
+export const isCompactRunColumnVisible = (
+  rows: readonly CostRunRow[],
+  select: (row: CostRunRow) => number | string | null,
+) =>
+  rows.some((row) => {
+    const value = select(row);
+    return value !== null && value !== 0 && value !== "";
+  });
+export const formatRate = (value: number | null, locale: CostLocale) =>
+  new Intl.NumberFormat(locale, { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(
+    value ?? 0,
+  );
+export const formatBrlRate = (value: number | null, locale: CostLocale) =>
+  `R$ ${formatRate(value, locale)}`;
+export const formatUsd = (value: number | null, locale: CostLocale) =>
+  new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  }).format(value ?? 0);
+
+const normalized = (value: string | null) => {
+  const result = value?.trim() ?? "";
+  return result === "" || result.toLowerCase() === "unknown" ? null : result;
+};
+const detail = (value: string, _kind: "effort" | "speed", locale: CostLocale) => {
+  if (locale !== "pt-BR") return value;
+  return (
+    {
+      low: "Leve",
+      medium: "M\u00e9dio",
+      high: "Alto",
+      xhigh: "Extra alto",
+      max: "Ultra",
+      default: "Padr\u00e3o",
+      priority: "R\u00e1pido",
+    }[value] ?? value
+  );
+};
+
+export const formatMultiplierPair = (
+  input: number | null,
+  output: number | null,
+  locale: CostLocale,
+) => {
+  if (input === null || output === null)
+    return locale === "pt-BR" ? "Indispon\u00edvel" : "Unavailable";
+  return `${input.toLocaleString("en-US", { maximumFractionDigits: 3 })}\u00d7 / ${output.toLocaleString("en-US", { maximumFractionDigits: 3 })}\u00d7`;
+};
+export const formatReasoningEffort = (
+  effective: string | null,
+  requested: string | null,
+  locale: CostLocale,
+) => {
+  const actual = normalized(effective);
+  if (actual !== null) return detail(actual, "effort", locale);
+  const asked = normalized(requested);
+  if (asked === null) return "-";
+  const label = detail(asked, "effort", locale);
+  return locale === "pt-BR"
+    ? `${label} (solicitado; efetivo -)`
+    : `${label} (requested; effective -)`;
+};
+export const formatServiceTier = (value: string | null, locale: CostLocale) => {
+  const tier = normalized(value);
+  return tier === null
+    ? locale === "pt-BR"
+      ? "Padr\u00e3o"
+      : "Standard"
+    : detail(tier, "speed", locale);
+};
+export const costRunsScrollLabel = (locale: CostLocale) =>
+  locale === "pt-BR"
+    ? "Tabela de custos por invoca\u00e7\u00e3o com rolagem horizontal"
+    : "Agent invocation costs table with horizontal scrolling";
+export const costGroupsScrollLabel = (locale: CostLocale) =>
+  locale === "pt-BR"
+    ? "Tabela de custos agrupados com rolagem horizontal"
+    : "Grouped costs table with horizontal scrolling";
+export const formatDateTime = (value: string, locale: CostLocale) =>
+  !value || Number.isNaN(Date.parse(value))
+    ? "\u2014"
+    : new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "medium" }).format(
+        new Date(value),
+      );
+export const formatCostPeriodLabel = (
+  value: string,
+  period: "daily" | "monthly" | "annual",
+  locale: CostLocale,
+) => {
+  if (period === "annual") return value.slice(0, 4);
+  if (period === "monthly") return value.slice(0, 7);
+  const date = new Date(`${value}T12:00:00.000Z`);
+  return Number.isNaN(date.getTime())
+    ? value
+    : new Intl.DateTimeFormat(locale, { dateStyle: "short", timeZone: "UTC" }).format(date);
+};
+export const costPeriodTotalAriaLabel = ({
+  locale,
+  duration,
+  tokens,
+  cost,
+  currency,
+}: {
+  locale: CostLocale;
+  duration: string;
+  tokens: string;
+  cost: string;
+  currency: CostCurrency;
+}) =>
+  locale === "pt-BR"
+    ? `Total geral \u2014 Tempo: ${duration}; Tokens: ${tokens}; ${currency}: ${cost}`
+    : `Grand total \u2014 Time: ${duration}; Tokens: ${tokens}; Cost (${currency}): ${cost}`;

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

@@ -1,2 +1,5 @@
 export * from "./CostMonitorPage.js";
+export { CostRunsTable } from "./CostTables.js";
+export type { CompactLifecycleCostPage } from "./CompactLifecycleCostTable.js";
+export { matches as matchesCostRunFilter } from "./cost-monitor-row-filters.js";
 export type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";

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

@@ -76,6 +76,74 @@ describe("enrichPeriodCostGroups", () => {
     });
   });
 
+  it("counts typed Evidence by observed month and de-duplicates legacy references", () => {
+    const rows = enrichPeriodCostGroups(
+      [],
+      {
+        prds: [],
+        specs: [],
+        tasks: [
+          {
+            created_at: "2026-07-31T12:00:00.000Z",
+            result: { evidence_ids: ["EVD-TYPED", "EVD-LEGACY"] },
+          },
+        ],
+        evidences: [{ id: "EVD-TYPED", observed_at: "2026-08-01T12:00:00.000Z" }],
+      },
+      "monthly",
+    );
+
+    expect(rows.map((row) => [row.key, row.evidence_count])).toEqual([
+      ["2026-08", 1],
+      ["2026-07", 1],
+    ]);
+  });
+
+  it("counts typed Validation by execution month instead of Task creation month", () => {
+    const rows = enrichPeriodCostGroups(
+      [],
+      {
+        prds: [],
+        specs: [],
+        tasks: [
+          {
+            created_at: "2026-07-31T12:00:00.000Z",
+            result: null,
+            test_count: 99,
+          },
+        ],
+        validations: [{ id: "TEST-TYPED", executed_at: "2026-08-01T12:00:00.000Z" }],
+      },
+      "monthly",
+    );
+
+    expect(rows.map((row) => [row.key, row.test_count])).toEqual([
+      ["2026-08", 1],
+      ["2026-07", 0],
+    ]);
+  });
+
+  it("uses created Tasks instead of financially active Tasks in the period total", () => {
+    const base = runGroups.at(0);
+    if (base === undefined) throw new Error("Expected base period group");
+    const rows = enrichPeriodCostGroups(
+      [{ ...base, key: "2026-08", run_count: 74, task_count: 74 }],
+      {
+        prds: [],
+        specs: [],
+        tasks: Array.from({ length: 89 }, () => ({
+          created_at: "2026-08-02T12:00:00.000Z",
+          result: null,
+        })),
+      },
+      "monthly",
+    );
+
+    expect(rows).toMatchObject([
+      { key: "2026-08", run_count: 74, task_count: 89, tasksCreated: 89 },
+    ]);
+  });
+
   it("divides total duration by every day in the period", () => {
     const rows = [
       runGroups[0] as CostGroupRow,