@zaip-ai/cli 3.3.0 → 3.5.0

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

@@ -124,7 +124,7 @@ describe("Cost Monitor V2", () => {
       }),
     );
   });
-  it("keeps priced Runs whose duration was not observed", () => {
+  it("keeps legacy persisted duration when raw source timing is absent", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -139,13 +139,13 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-WITHOUT-OBSERVED-DURATION",
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
-        estimation_basis: "token_budget_v1:4_000_000_tokens_per_hour",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
+        estimation_basis: null,
       }),
     );
   });
-  it("keeps every tokenized Run positive when factual timing would exhaust the canonical budget", () => {
+  it("does not allocate a duration budget to a tokenized Run without timing", () => {
     const operations = operationsWithPricedRun();
     operations.summary.overview_metrics = {
       ...(operations.summary.overview_metrics ?? {}),
@@ -162,17 +162,16 @@ describe("Cost Monitor V2", () => {
       duration_ms: null,
     });
     const rows = buildCostMonitorProjection(operations).runs;
-    const rootDuration = rows.find((row) => row.run_id === root.id)?.duration_ms ?? 0;
-    const tokenOnlyDuration = rows.find((row) => row.run_id === "TOKEN-ONLY")?.duration_ms ?? 0;
-    expect(rootDuration).toBeGreaterThan(0);
-    expect(tokenOnlyDuration).toBeGreaterThan(0);
-    expect(rootDuration + tokenOnlyDuration).toBe(3_600_000);
+    const rootDuration = rows.find((row) => row.run_id === root.id)?.duration_ms;
+    const tokenOnlyDuration = rows.find((row) => row.run_id === "TOKEN-ONLY")?.duration_ms;
+    expect(rootDuration).toBe(4_000_000);
+    expect(tokenOnlyDuration).toBeNull();
     expect(rows.find((row) => row.run_id === "TOKEN-ONLY")).toMatchObject({
-      duration_provenance: "estimated",
-      estimation_basis: "operations_canonical_budget_v1:proportional_tokens",
+      duration_provenance: "unavailable",
+      estimation_basis: null,
     });
   });
-  it("reconciles the all-period dimensional total to the displayed whole-hour budget", () => {
+  it("keeps dimensional durations sourced from factual Runs instead of overview budgets", () => {
     const operations = operationsWithPricedRun();
     operations.filters = { from: null, to: null };
     operations.summary.overview_metrics = {
@@ -181,13 +180,13 @@ describe("Cost Monitor V2", () => {
     } as never;
     const projection = buildCostMonitorProjection(operations);
     expect(projection.groups.models.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
-      76 * 3_600_000,
+      40_000,
     );
     expect(projection.groups.daily.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
-      76 * 3_600_000,
+      40_000,
     );
   });
-  it("enforces tokens imply positive time for every Run and aggregate", () => {
+  it("preserves an observed zero duration for a tokenized Run", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0]!;
     operations.runs.push({
@@ -197,19 +196,21 @@ describe("Cost Monitor V2", () => {
       duration_ms: 0,
     });
     const projection = buildCostMonitorProjection(operations);
-    expect(
-      projection.runs
-        .filter((row) => (row.total_tokens ?? 0) > 0)
-        .every((row) => (row.duration_ms ?? 0) > 0),
-    ).toBe(true);
-    for (const groups of Object.values(projection.groups))
-      expect(
-        groups
-          .filter((row) => (row.total_tokens ?? 0) > 0)
-          .every((row) => row.duration.known_sum > 0),
-      ).toBe(true);
+    expect(projection.runs).toContainEqual(
+      expect.objectContaining({
+        run_id: "TOKENIZED-ZERO",
+        duration_ms: 0,
+        duration_provenance: "observed",
+        estimation_basis: null,
+      }),
+    );
+    expect(projection.groups.daily[0]?.duration).toMatchObject({
+      known_sum: 40_000,
+      unknown: 0,
+      complete: true,
+    });
   });
-  it("repairs a tokenized observed zero so the invariant remains positive", () => {
+  it("keeps unavailable and observed-zero duration distinct", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -224,15 +225,15 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
       }),
     );
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-OBSERVED-ZERO",
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 0,
+        duration_provenance: "observed",
       }),
     );
   });
@@ -293,13 +294,16 @@ describe("Cost Monitor V2", () => {
     const bounded = withTimestamp("2026-08-01T00:01:00.000Z");
     expect(outlier).not.toEqual(bounded);
     expect(outlier).toContainEqual(
-      expect.objectContaining({ key: "2026-08-10", duration_ms: 900_000 }),
+      expect.objectContaining({
+        key: "2026-08-10",
+        duration_ms: 0,
+        duration: expect.objectContaining({ known_sum: 0, unknown: 1, complete: false }),
+      }),
     );
     expect(outlier).toContainEqual(
       expect.objectContaining({
-        // Daily wall-clock matches Operations: root factual durations are
-        // retained regardless of whether they were observed or reconciled.
-        // The estimate is token-backed, not lifecycle elapsed time.
+        // Daily root durations retain their observed, reconciled, and legacy
+        // facts. The unavailable outlier contributes no inferred duration.
         duration_ms: 13_500_000,
         duration: { known_sum: 13_500_000, unknown: 0, complete: true, coverage_ratio: 1 },
       }),
@@ -347,7 +351,7 @@ describe("Cost Monitor V2", () => {
     expect(projection.specs).toContainEqual(
       expect.objectContaining({
         id: "SPEC-DURATION",
-        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+        duration_ms: 0,
       }),
     );
   });
@@ -397,7 +401,7 @@ describe("Cost Monitor V2", () => {
     expect(projection.specs).toContainEqual(
       expect.objectContaining({
         id: "SPEC-VISIBLE-ROOT",
-        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+        duration_ms: null,
       }),
     );
   });
@@ -445,8 +449,8 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
         estimated_brl: null,
       }),
     );
@@ -754,47 +758,4 @@ describe("Cost Monitor V2", () => {
     });
     expect(projection.overview).toMatchObject({ estimated_usd: 1.25, estimated_brl: 6.25 });
   });
-  it("retains token-bearing Runs when a cost cannot be established", () => {
-    const operations = operationsWithPricedRun();
-    const source = operations.runs[0];
-    if (!source) throw new Error("priced Run fixture is missing");
-    operations.runs = [
-      {
-        ...source,
-        id: "RUN-UNKNOWN-MODEL",
-        model: "unknown-model",
-        effective_model: "unknown-model",
-        service_tier: null,
-        usage: usage(metric({ tokens: 1_000, input: 900, cached: 800, output: 100, events: 1 })),
-      },
-      {
-        ...source,
-        id: "RUN-UNKNOWN-TOKENS",
-        model: "gpt-5.4",
-        effective_model: "gpt-5.4",
-        service_tier: null,
-        usage: usage(metric({ tokens: 1_000, input: 900, output: 100, events: 1 })),
-      },
-    ];
-    const projection = buildCostMonitorProjection(operations, {
-      catalog: gpt54Catalog(),
-      fxRate: fxRate(5.5),
-      currency: "BRL",
-    });
-    expect(projection.runs).toHaveLength(2);
-    expect(projection.runs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          run_id: "RUN-UNKNOWN-MODEL",
-          total_tokens: 1_000,
-          estimated_brl: null,
-        }),
-        expect.objectContaining({
-          run_id: "RUN-UNKNOWN-TOKENS",
-          total_tokens: 1_000,
-          estimated_brl: null,
-        }),
-      ]),
-    );
-  });
 });

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

@@ -20,7 +20,6 @@ import {
   type CostRunRow,
   durationAggregationRows,
 } from "../contracts.js";
-import { estimatedDurationMs, TOKEN_DURATION_ESTIMATE_BASIS } from "../duration-estimate.js";
 import { normalizeCostProvider } from "../provider.js";
 import { aggregateTaskCostRows } from "../task-cost-groups.js";
 import { aggregateRows, averageAvailable } from "./aggregate.js";
@@ -76,7 +75,7 @@ export function buildCostMonitorProjection(
     const totalTokens = tokenTelemetryKnown
       ? inclusiveTokenTotal(recordedRun?.usage.total.tokens ?? usage.tokens)
       : null;
-    const duration = costDuration(run, totalTokens);
+    const duration = costDuration(run);
     return {
       run_id: run.id,
       execution_id: run.execution_id,
@@ -111,10 +110,7 @@ export function buildCostMonitorProjection(
       started_at: run.started_at,
       finished_at: run.finished_at,
       ...duration,
-      estimation_basis:
-        duration.duration_provenance === "estimated"
-          ? TOKEN_DURATION_ESTIMATE_BASIS
-          : (run.estimation_basis ?? null),
+      estimation_basis: null,
       source_started_at: run.source_started_at ?? null,
       source_finished_at: run.source_finished_at ?? null,
       capture_lag_ms: run.capture_lag_ms ?? null,
@@ -157,14 +153,9 @@ export function buildCostMonitorProjection(
       artifact_path: run.artifact_path,
     };
   });
-  // The Operations overview is the canonical, non-overlapping duration
-  // budget. Keep factual post-cutoff root execution timing; distribute only
-  // its remaining budget across tokenized non-canonical Runs. This makes every
-  // Cost dimension consume one effective value per Run without reusing
-  // lifecycle elapsed time or modifying token/cost telemetry.
-  const rows = assertTokenDurationInvariant(
-    allocateCanonicalDurationBudget(enforceTokenDurationInvariant(sourceRows), operations),
-  );
+  // Cost dimensions carry only factual source timing. Tokens and lifecycle
+  // budgets are not duration evidence, so unavailable timing remains null.
+  const rows = sourceRows;
   const group = (
     select: (row: CostRunRow) => string,
     label?: (key: string) => string,
@@ -239,8 +230,8 @@ export function buildCostMonitorProjection(
     configured_agents: configuredAgents,
     usage,
     origins,
-    prds: repriceMacros(operations.prds, tableRuns, rows),
-    specs: repriceMacros(operations.specs, tableRuns, rows),
+    prds: repriceMacros(operations.prds, tableRuns),
+    specs: repriceMacros(operations.specs, tableRuns),
     runs: [...rows].sort((left, right) => right.started_at.localeCompare(left.started_at)),
     groups: {
       conversations: aggregateRows(
@@ -301,77 +292,6 @@ export function buildCostMonitorProjection(
   };
 }
 
-function allocateCanonicalDurationBudget(
-  rows: readonly CostRunRow[],
-  operations: OperationsProjection,
-): CostRunRow[] {
-  const rawBudget = operations.summary.overview_metrics?.duration_ms;
-  if (typeof rawBudget !== "number" || rawBudget < 0) return [...rows];
-  // The all-period Operations card is the human-facing reconciliation target
-  // and is expressed in whole hours. Use that same precision for the Cost
-  // allocation so its dimensional footers reconcile to the displayed 76 h,
-  // while explicit date ranges retain their exact millisecond budget.
-  const budget =
-    operations.filters.from === null && operations.filters.to === null
-      ? Math.round(rawBudget / 3_600_000) * 3_600_000
-      : rawBudget;
-  const tokenized = rows.filter((row) => (row.total_tokens ?? 0) > 0);
-  if (tokenized.length === 0) return [...rows];
-  // A non-positive/sub-millisecond-per-Run budget contradicts the invariant.
-  // Prefer the deterministic token estimate instead of emitting 0 ms.
-  if (budget < tokenized.length) return [...rows];
-  const tokenTotal = tokenized.reduce((total, row) => total + (row.total_tokens ?? 0), 0);
-  // Reserve one millisecond for every tokenized Run before distributing the
-  // remainder. A previous factual-first allocation could exhaust the budget
-  // and leave a recent day displaying 0 s despite millions of tokens.
-  const minimumPerRun = budget >= tokenized.length ? 1 : 0;
-  const distributable = Math.max(0, budget - minimumPerRun * tokenized.length);
-  let assigned = 0;
-  return rows.map((row) => {
-    if (!tokenized.includes(row))
-      return {
-        ...row,
-        duration_ms: null,
-        duration_provenance: "unavailable",
-        estimation_basis: null,
-      };
-    const isLast = tokenized.at(-1) === row;
-    const duration_ms = isLast
-      ? budget - assigned
-      : minimumPerRun + Math.floor((distributable * (row.total_tokens ?? 0)) / tokenTotal);
-    assigned += duration_ms;
-    return {
-      ...row,
-      duration_ms,
-      duration_provenance: "estimated",
-      estimation_basis: "operations_canonical_budget_v1:proportional_tokens",
-    };
-  });
-}
-
-export function enforceTokenDurationInvariant(rows: readonly CostRunRow[]): CostRunRow[] {
-  return rows.map((row) => {
-    if ((row.total_tokens ?? 0) <= 0 || (row.duration_ms ?? 0) > 0) return row;
-    const duration_ms = estimatedDurationMs(row.total_tokens);
-    if (duration_ms === null || duration_ms <= 0) return row;
-    return {
-      ...row,
-      duration_ms,
-      duration_provenance: "estimated",
-      estimation_basis: TOKEN_DURATION_ESTIMATE_BASIS,
-    };
-  });
-}
-
-function assertTokenDurationInvariant(rows: readonly CostRunRow[]): CostRunRow[] {
-  const invalid = rows.find((row) => (row.total_tokens ?? 0) > 0 && (row.duration_ms ?? 0) <= 0);
-  if (invalid !== undefined)
-    throw new TypeError(
-      `Cost Monitor invariant violated: ${invalid.run_id} has tokens without positive duration`,
-    );
-  return [...rows];
-}
-
 function withCreatedTaskCounts(
   groups: CostMonitorProjection["groups"]["daily"],
   tasks: readonly { created_at: string }[],
@@ -668,7 +588,6 @@ function singleFxRate(rates: readonly number[]): number | null {
 
 function costDuration(
   run: Pick<RunProjection, "source_duration_ms" | "duration_ms" | "duration_provenance">,
-  totalTokens: number | null,
 ) {
   if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0)
     return { duration_ms: run.source_duration_ms, duration_provenance: "observed" as const };
@@ -678,18 +597,16 @@ function costDuration(
   if (
     typeof run.duration_ms === "number" &&
     run.duration_ms >= 0 &&
-    (run.duration_provenance === "observed" ||
+    (run.duration_provenance === undefined ||
+      run.duration_provenance === "observed" ||
       run.duration_provenance === "reconciled" ||
       run.duration_provenance === "legacy_inferred")
   ) {
     return {
       duration_ms: run.duration_ms,
-      duration_provenance: run.duration_provenance,
+      duration_provenance: run.duration_provenance ?? "legacy_inferred",
     };
   }
-  const estimated = estimatedDurationMs(totalTokens);
-  if (estimated !== null)
-    return { duration_ms: estimated, duration_provenance: "estimated" as const };
   return { duration_ms: null, duration_provenance: "unavailable" as const };
 }
 
@@ -744,9 +661,8 @@ function inclusiveTokenTotal(
 function repriceMacros(
   macros: readonly MacroProjection[],
   runs: readonly RunProjection[],
-  costRows: readonly CostRunRow[],
 ): MacroProjection[] {
-  const repriced = macros.map((macro) => {
+  return macros.map((macro) => {
     const declaredRunIds = new Set(macro.run_ids);
     const relatedRuns = runs.filter(
       (run) =>
@@ -759,22 +675,6 @@ function repriceMacros(
       usage: usageForRuns(relatedRuns),
     };
   });
-  const durationBudget = costRows.reduce((sum, row) => sum + (row.duration_ms ?? 0), 0);
-  const tokenized = repriced.filter((macro) => (macro.usage.total.tokens.total ?? 0) > 0);
-  const tokenBudget = tokenized.reduce(
-    (sum, macro) => sum + (macro.usage.total.tokens.total ?? 0),
-    0,
-  );
-  let assigned = 0;
-  return repriced.map((macro) => {
-    if (!tokenized.includes(macro)) return { ...macro, duration_ms: null };
-    const isLast = tokenized.at(-1) === macro;
-    const duration_ms = isLast
-      ? durationBudget - assigned
-      : Math.round((durationBudget * (macro.usage.total.tokens.total ?? 0)) / tokenBudget);
-    assigned += duration_ms;
-    return { ...macro, duration_ms };
-  });
 }
 
 function unique(values: readonly string[]): string[] {

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

@@ -6,6 +6,52 @@ import {
 } from "./build-cost-summary-projection.js";
 
 describe("buildCostSummaryProjection", () => {
+  it("keeps compact SQLite filter dimensions without hydrating Run rows", () => {
+    const operations = {
+      schema_version: 1,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 2, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(
+      {
+        periods: { daily: {} },
+        filters_available: {
+          providers: ["anthropic", "openai"],
+          agents: ["zaip-agent-builder"],
+          models: ["claude-sonnet", "gpt-5"],
+          statuses: ["active", "completed"],
+          priorities: ["high", "low"],
+          risks: ["standard", "high"],
+          phases: ["planning", "execution"],
+          origins: ["conversation", "task"],
+          work_types: ["new", "rework"],
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    );
+
+    expect(projection.runs).toEqual([]);
+    expect(projection.filters_available).toEqual({
+      providers: ["anthropic", "openai"],
+      agents: ["zaip-agent-builder"],
+      models: ["claude-sonnet", "gpt-5"],
+      statuses: ["active", "completed"],
+      priorities: ["high", "low"],
+      risks: ["standard", "high"],
+      phases: ["planning", "execution"],
+      origins: ["conversation", "task"],
+      work_types: ["new", "rework"],
+    });
+  });
+
   it("retains factual USD from a compact SQLite summary with no Run rows", () => {
     const operations = {
       schema_version: 2,
@@ -496,7 +542,7 @@ describe("buildCostSummaryProjection", () => {
       usd: null,
       brl: null,
       metrics: {
-        duration: { eligible_runs: 3, known_runs: 3, unknown_runs: 0 },
+        duration: { eligible_runs: 3, known_runs: 0, unknown_runs: 3 },
         tokens: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
         usd: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
         brl: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
@@ -574,184 +620,4 @@ describe("buildCostSummaryProjection", () => {
       expect.arrayContaining([expect.objectContaining({ key: "unknown" })]),
     );
   });
-
-  it("uses the same token-backed effective duration in the fast daily projection", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-07": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 1,
-            usage: {
-              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 1,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "TOKEN-ONLY",
-          started_at: "2026-08-07T12:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: null,
-          total_tokens: 4_000_000,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-      ],
-    };
-    const operations = {
-      filters: { from: "2026-08-07", to: "2026-08-07" },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
-    expect(projection.groups.daily[0]?.duration).toMatchObject({
-      known_sum: 3_600_000,
-      unknown: 0,
-      complete: true,
-    });
-  });
-
-  it("enforces positive daily time from period tokens even without compact Run metrics", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-07": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 1,
-            usage: {
-              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 1,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-          },
-        },
-      },
-    };
-    const operations = {
-      filters: { from: "2026-08-07", to: "2026-08-07" },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
-    expect(projection.groups.daily[0]).toMatchObject({
-      total_tokens: 4_000_000,
-      duration_ms: 3_600_000,
-      duration: { known_sum: 3_600_000, unknown: 0, complete: true },
-    });
-  });
-
-  it("uses the canonical root duration and excludes child and conversation duration", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-07-24": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 3,
-            usage: {
-              total_tokens: { known_sum: 3, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 3,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-            duration: { known_sum: 60_109_200, unknown: 0, complete: true, coverage_ratio: 1 },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "ROOT",
-          started_at: "2026-07-24T20:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 23_241_600,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-        {
-          id: "CHILD",
-          started_at: "2026-07-24T20:01:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: "ROOT",
-          status: null,
-          duration_ms: 36_867_600,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-        {
-          id: "CONVERSATION",
-          started_at: "2026-07-24T20:02:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "conversation",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 1_000,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-      ],
-      canonical_daily_duration_ms: { "2026-07-24": 23_241_600 },
-    };
-    const operations = {
-      filters: { from: null, to: null },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const row = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily.find(
-      (value) => value.key === "2026-07-24",
-    )!;
-
-    expect(row.duration.known_sum).toBe(23_241_600);
-    expect(row.duration.coverage_ratio).toBe(1);
-    expect(row.run_count).toBe(3);
-  });
 });