@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -1,7 +1,4 @@
-import {
-  globalLegacyEffortDurationMs,
-  type OperationsProjection,
-} from "@zaip-ai/dashboard-operations/contracts";
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
 import { describe, expect, it } from "vitest";
 import {
   buildCostSummaryProjection,
@@ -11,25 +8,49 @@ import {
 describe("buildCostSummaryProjection", () => {
   it("retains factual USD from a compact SQLite summary with no Run rows", () => {
     const operations = {
-      schema_version: 2, layout_version: 2, readonly: true, source: ".agents/records",
-      filters: { from: null, to: null }, summary: { task_count: 1, overview_metrics: {}, usage: {} },
-      prds: [], specs: [], runs: [],
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 1, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
     } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection({
-      periods: { daily: {
-        "2026-08-19": {
-          prds: 0, specs: 0, tasks: 1, validations: 0, evidences: 0, runs: 1,
-          usage: {
-            total_tokens: { known_sum: 100, unknown: 0, complete: true, coverage_ratio: 1 },
-            cost: { known_sum: 47.5, unknown: 0, complete: true, coverage_ratio: 1, currency: "BRL" },
+    const projection = buildCostSummaryProjection(
+      {
+        periods: {
+          daily: {
+            "2026-08-19": {
+              prds: 0,
+              specs: 0,
+              tasks: 1,
+              validations: 0,
+              evidences: 0,
+              runs: 1,
+              usage: {
+                total_tokens: { known_sum: 100, unknown: 0, complete: true, coverage_ratio: 1 },
+                cost: {
+                  known_sum: 47.5,
+                  unknown: 0,
+                  complete: true,
+                  coverage_ratio: 1,
+                  currency: "BRL",
+                },
+              },
+            },
           },
         },
-      } },
-      daily_rows: [{ key: "2026-08-19", total_cost_usd: 8.7, total_cost_brl: 47.5 }],
-      cost_monitor_daily_duration: {
-        "2026-08-19": { known_sum: 60_000, eligible_runs: 1, known_runs: 1 },
+        daily_rows: [{ key: "2026-08-19", total_cost_usd: 8.7, total_cost_brl: 47.5 }],
+        cost_monitor_daily_duration: {
+          "2026-08-19": { known_sum: 60_000, eligible_runs: 1, known_runs: 1 },
+        },
       },
-    }, operations, "USD", null);
+      operations,
+      "USD",
+      null,
+    );
 
     expect(projection).toMatchObject({
       aggregate_only: true,
@@ -43,41 +64,101 @@ describe("buildCostSummaryProjection", () => {
     const metric = (total: number) => ({
       events: 1,
       duration_ms: total,
-      tokens: { input: total, cached_input: total / 2, output: total / 4, reasoning: total / 8, total: total + total / 4 },
+      tokens: {
+        input: total,
+        cached_input: total / 2,
+        output: total / 4,
+        reasoning: total / 8,
+        total: total + total / 4,
+      },
       cost: { usd: total / 100, brl: total / 20 },
       coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
     });
     const aggregate = {
-      conversation: metric(10), planning: metric(20), execution: metric(30),
-      total: metric(60), new_work: metric(60), rework: metric(0),
+      conversation: metric(10),
+      planning: metric(20),
+      execution: metric(30),
+      total: metric(60),
+      new_work: metric(60),
+      rework: metric(0),
     };
     const operations = {
-      schema_version: 2, layout_version: 2, readonly: true, source: ".agents/records",
-      filters: { from: null, to: null }, summary: { task_count: 0, overview_metrics: {}, usage: {} },
-      prds: [], specs: [], runs: [],
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 0, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
     } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection({
-      periods: { daily: {} },
-      aggregate_usage: aggregate,
-      // Contradictory legacy input proves the aggregate transport wins.
-      run_metrics: [{
-        id: "LEGACY", started_at: "2026-08-10T12:00:00.000Z", finished_at: null,
-        task_id: null, phase: "execution", parent_run_id: null, status: null,
-        duration_ms: 999, total_tokens: 999, cost: 999, currency: "BRL", events: 999,
-      }],
-    }, operations, "BRL", null);
+    const projection = buildCostSummaryProjection(
+      {
+        periods: { daily: {} },
+        aggregate_usage: aggregate,
+        // Contradictory legacy input proves the aggregate transport wins.
+        run_metrics: [
+          {
+            id: "LEGACY",
+            started_at: "2026-08-10T12:00:00.000Z",
+            finished_at: null,
+            task_id: null,
+            phase: "execution",
+            parent_run_id: null,
+            status: null,
+            duration_ms: 999,
+            total_tokens: 999,
+            cost: 999,
+            currency: "BRL",
+            events: 999,
+          },
+        ],
+      },
+      operations,
+      "BRL",
+      null,
+    );
 
     expect(projection.usage).toBe(aggregate);
     expect(projection.runs).toEqual([]);
-    expect(projection.usage.total.tokens).toMatchObject({ input: 60, cached_input: 30, output: 15, reasoning: 7.5, total: 75 });
+    expect(projection.usage.total.tokens).toMatchObject({
+      input: 60,
+      cached_input: 30,
+      output: 15,
+      reasoning: 7.5,
+      total: 75,
+    });
   });
 
   it("derives phase-aware inclusive usage from compact Run facts when the aggregate transport is empty", () => {
-    const run = (id: string, phase: "conversation" | "planning" | "execution", input: number, cached: number, output: number, reasoning: number, cost: number, duration: number) => ({
-      id, started_at: "2026-08-10T12:00:00.000Z", finished_at: null, task_id: null,
-      phase, parent_run_id: null, status: null, duration_ms: duration, source_duration_ms: duration,
-      input_tokens: input, cached_input_tokens: cached, output_tokens: output,
-      reasoning_tokens: reasoning, total_tokens: input + output, cost, currency: "BRL", events: 1,
+    const run = (
+      id: string,
+      phase: "conversation" | "planning" | "execution",
+      input: number,
+      cached: number,
+      output: number,
+      reasoning: number,
+      cost: number,
+      duration: number,
+    ) => ({
+      id,
+      started_at: "2026-08-10T12:00:00.000Z",
+      finished_at: null,
+      task_id: null,
+      phase,
+      parent_run_id: null,
+      status: null,
+      duration_ms: duration,
+      source_duration_ms: duration,
+      input_tokens: input,
+      cached_input_tokens: cached,
+      output_tokens: output,
+      reasoning_tokens: reasoning,
+      total_tokens: input + output,
+      cost,
+      currency: "BRL",
+      events: 1,
     });
     const summary = {
       periods: { daily: {} },
@@ -88,61 +169,138 @@ describe("buildCostSummaryProjection", () => {
       ],
     } as CostSummarySource;
     const operations = {
-      schema_version: 1, layout_version: 2, readonly: true, source: ".agents/records",
-      filters: { from: null, to: null }, summary: { task_count: 0, usage: {} },
-      prds: [], specs: [], runs: [],
+      schema_version: 1,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 0, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
     } as unknown as OperationsProjection;
 
     const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
 
     expect(projection.aggregate_only).toBe(true);
     expect(projection.runs).toEqual([]);
-    expect(projection.usage.conversation.tokens).toMatchObject({ input: 10, cached_input: 4, output: 5, reasoning: 2, total: 15 });
-    expect(projection.usage.planning.tokens).toMatchObject({ input: 20, cached_input: 8, output: 7, reasoning: 3, total: 27 });
-    expect(projection.usage.execution.tokens).toMatchObject({ input: 30, cached_input: 12, output: 9, reasoning: 4, total: 39 });
-    expect(projection.usage.total.tokens).toMatchObject({ input: 60, cached_input: 24, output: 21, reasoning: 9, total: 81 });
+    expect(projection.usage.conversation.tokens).toMatchObject({
+      input: 10,
+      cached_input: 4,
+      output: 5,
+      reasoning: 2,
+      total: 15,
+    });
+    expect(projection.usage.planning.tokens).toMatchObject({
+      input: 20,
+      cached_input: 8,
+      output: 7,
+      reasoning: 3,
+      total: 27,
+    });
+    expect(projection.usage.execution.tokens).toMatchObject({
+      input: 30,
+      cached_input: 12,
+      output: 9,
+      reasoning: 4,
+      total: 39,
+    });
+    expect(projection.usage.total.tokens).toMatchObject({
+      input: 60,
+      cached_input: 24,
+      output: 21,
+      reasoning: 9,
+      total: 81,
+    });
     expect(projection.usage.total.cost.brl).toBe(6);
     expect(projection.usage.total.duration_ms).toBe(600);
   });
 
   it("uses segment-backed real model groups for the aggregate-only first fold", () => {
     const operations = {
-      schema_version: 2, layout_version: 2, readonly: true, source: ".agents/records",
-      filters: { from: null, to: null }, summary: { task_count: 0, overview_metrics: {}, usage: {} }, prds: [], specs: [], runs: [],
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 0, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
     } as unknown as OperationsProjection;
     const group = (key: string, brl: number) => ({
-      key, label: key, latest_started_at: "", run_count: 0, task_count: 0,
-      prd_count: 0, spec_count: 0, evidence_count: 0, test_count: 0, event_count: 0,
-      total_tokens: 1, estimated_usd: brl / 5, estimated_brl: brl, duration_ms: null,
+      key,
+      label: key,
+      latest_started_at: "",
+      run_count: 0,
+      task_count: 0,
+      prd_count: 0,
+      spec_count: 0,
+      evidence_count: 0,
+      test_count: 0,
+      event_count: 0,
+      total_tokens: 1,
+      estimated_usd: brl / 5,
+      estimated_brl: brl,
+      duration_ms: null,
       duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
       coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
     });
-    const projection = buildCostSummaryProjection({
-      periods: { daily: {} },
-      model_groups: [group("gpt-real", 10), group("claude-real", 5)],
-    }, operations, "BRL", null);
+    const projection = buildCostSummaryProjection(
+      {
+        periods: { daily: {} },
+        model_groups: [group("gpt-real", 10), group("claude-real", 5)],
+      },
+      operations,
+      "BRL",
+      null,
+    );
 
     expect(projection.groups.models.map((row) => [row.key, row.estimated_brl])).toEqual([
-      ["gpt-real", 10], ["claude-real", 5],
+      ["gpt-real", 10],
+      ["claude-real", 5],
     ]);
   });
 
   it("excludes mixed and unavailable residuals from the model chart", () => {
     const operations = {
-      schema_version: 2, layout_version: 2, readonly: true, source: ".agents/records",
-      filters: { from: null, to: null }, summary: { task_count: 0, overview_metrics: {}, usage: {} }, prds: [], specs: [], runs: [],
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 0, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
     } as unknown as OperationsProjection;
     const group = (key: string) => ({
-      key, label: key, latest_started_at: "", run_count: 0, task_count: null,
-      prd_count: 0, spec_count: 0, evidence_count: 0, test_count: 0, event_count: 0,
-      total_tokens: 1, estimated_usd: 1, estimated_brl: 5, duration_ms: null,
+      key,
+      label: key,
+      latest_started_at: "",
+      run_count: 0,
+      task_count: null,
+      prd_count: 0,
+      spec_count: 0,
+      evidence_count: 0,
+      test_count: 0,
+      event_count: 0,
+      total_tokens: 1,
+      estimated_usd: 1,
+      estimated_brl: 5,
+      duration_ms: null,
       duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
       coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
     });
-    const projection = buildCostSummaryProjection({
-      periods: { daily: {} },
-      model_groups: [group("gpt-real"), group("mixed"), group("unknown"), group("unavailable")],
-    }, operations, "BRL", null);
+    const projection = buildCostSummaryProjection(
+      {
+        periods: { daily: {} },
+        model_groups: [group("gpt-real"), group("mixed"), group("unknown"), group("unavailable")],
+      },
+      operations,
+      "BRL",
+      null,
+    );
 
     expect(projection.groups.models.map((row) => row.key)).toEqual(["gpt-real"]);
   });
@@ -596,361 +754,4 @@ describe("buildCostSummaryProjection", () => {
     expect(row.duration.coverage_ratio).toBe(1);
     expect(row.run_count).toBe(3);
   });
-
-  it("unions overlapping root execution intervals like Operations", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-07": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 2,
-            usage: {
-              total_tokens: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
-              cost: {
-                known_sum: 0,
-                unknown: 2,
-                complete: false,
-                coverage_ratio: 0,
-                currency: "BRL",
-              },
-            },
-            duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "LEFT",
-          started_at: "2026-08-07T12:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 3_600_000,
-          duration_started_at: "2026-08-07T12:00:00.000Z",
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-        {
-          id: "RIGHT",
-          started_at: "2026-08-07T12:30:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 3_600_000,
-          duration_started_at: "2026-08-07T12:30:00.000Z",
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-      ],
-    };
-    const operations = {
-      filters: { from: null, to: null },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    expect(
-      buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily[0]?.duration
-        .known_sum,
-    ).toBe(5_400_000);
-  });
-
-  it("keeps canonical root coverage without injecting the legacy baseline", () => {
-    const period = (runs: number) => ({
-      prds: 0,
-      specs: 0,
-      tasks: 0,
-      validations: 0,
-      evidences: 0,
-      runs,
-      usage: {
-        total_tokens: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0 },
-        cost: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0, currency: "BRL" },
-      },
-    });
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-02": {
-            ...period(2),
-            duration: { known_sum: 2_000, unknown: 0, complete: true, coverage_ratio: 1 },
-          },
-          "2026-08-03": {
-            ...period(1),
-            duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "PRE",
-          started_at: "2026-08-02T03:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 99_000,
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-        {
-          id: "POST",
-          started_at: "2026-08-02T04:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 2_000,
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-        {
-          id: "UNKNOWN",
-          started_at: "2026-08-03T12:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: null,
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-      ],
-      canonical_daily_duration_ms: { "2026-08-02": 101_000 },
-    };
-    const operations = {
-      filters: { from: null, to: null },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
-    const cutoffDay = projection.groups.daily.find((row) => row.key === "2026-08-02")!;
-    const unknownDay = projection.groups.daily.find((row) => row.key === "2026-08-03")!;
-
-    expect(cutoffDay).toMatchObject({
-      run_count: 2,
-      duration: {
-        known_sum: 101_000,
-        unknown: 0,
-        coverage_ratio: 1,
-      },
-      coverage_counts: {
-        metrics: { duration: { eligible_runs: 2, known_runs: 2, unknown_runs: 0 } },
-      },
-    });
-    expect(projection.groups.daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(
-      101_000,
-    );
-    expect(unknownDay.duration).toMatchObject({
-      known_sum: 0,
-      unknown: 0,
-      complete: true,
-      coverage_ratio: 1,
-    });
-    expect(projection.groups.monthly.find((row) => row.key === "2026-08")?.duration).toMatchObject({
-      unknown: 0,
-      complete: true,
-      coverage_ratio: 1,
-    });
-    expect(
-      projection.groups.monthly.find((row) => row.key === "2026-08")?.coverage_counts?.metrics
-        ?.duration,
-    ).toEqual({
-      eligible_runs: 2,
-      known_runs: 2,
-      unknown_runs: 0,
-    });
-    expect(projection.overview.average_run_duration_ms).toBe(2_000);
-    expect(projection.legacy_effort_baseline).toBeNull();
-
-    const filtered = buildCostSummaryProjection(
-      summary,
-      { ...operations, filters: { from: "2026-08-03", to: "2026-08-03" } },
-      "BRL",
-      null,
-    );
-    expect(filtered.legacy_effort_baseline).toBeNull();
-    expect(filtered.groups.daily).toHaveLength(1);
-  });
-
-  it("preserves each canonical SQLite day instead of redistributing duration by tokens", () => {
-    const period = (tokens: number) => ({
-      prds: 0,
-      specs: 0,
-      tasks: 0,
-      validations: 0,
-      evidences: 0,
-      runs: 1,
-      usage: {
-        total_tokens: { known_sum: tokens, unknown: 0, complete: true, coverage_ratio: 1 },
-        cost: { known_sum: 1, unknown: 0, complete: true, coverage_ratio: 1, currency: "BRL" as const },
-      },
-    });
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-01": period(1_000),
-          "2026-08-02": period(9_000),
-        },
-      },
-      canonical_daily_duration_ms: {
-        "2026-08-01": 9_000,
-        "2026-08-02": 1_000,
-      },
-    };
-    const operations = {
-      filters: { from: null, to: null },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-
-    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
-
-    expect(daily.find((row) => row.key === "2026-08-01")?.duration.known_sum).toBe(9_000);
-    expect(daily.find((row) => row.key === "2026-08-02")?.duration.known_sum).toBe(1_000);
-  });
-
-  it("uses São Paulo timestamp bounds for Cost daily labels and preserves the interval total", () => {
-    const period = () => ({
-      prds: 0,
-      specs: 0,
-      tasks: 0,
-      validations: 0,
-      evidences: 0,
-      runs: 0,
-      usage: {
-        total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
-        cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1, currency: "BRL" },
-      },
-    });
-    const summary: CostSummarySource = {
-      periods: {
-        daily: Object.fromEntries(
-          [
-            "2026-08-02",
-            "2026-08-03",
-            "2026-08-04",
-            "2026-08-05",
-            "2026-08-06",
-            "2026-08-07",
-            "2026-08-08",
-          ].map((day) => [day, period()]),
-        ),
-      },
-      run_metrics: [
-        {
-          id: "LEFT",
-          started_at: "2026-08-07T12:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 3_600_000,
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-        {
-          id: "RIGHT",
-          started_at: "2026-08-07T12:30:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 3_600_000,
-          total_tokens: null,
-          cost: null,
-          currency: null,
-          events: null,
-        },
-      ],
-    };
-    const operations = {
-      filters: { from: "2026-08-02T03:00:00.000Z", to: "2026-08-08T02:59:59.999Z" },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    summary.periods.daily["2026-08-07"] = {
-      ...period(),
-      duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
-    };
-    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
-
-    expect(daily.map((row) => row.key)).not.toContain("2026-08-08");
-    expect(daily.map((row) => row.key)).toEqual(
-      expect.arrayContaining(["2026-08-02", "2026-08-07"]),
-    );
-    expect(daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(5_400_000);
-  });
-  it("keeps factual duration visible while retaining partial financial coverage", () => {
-    const known = (known_sum: number) => ({ known_sum, unknown: 0, complete: true, coverage_ratio: 1 });
-    const period = {
-      prds: 0, specs: 0, tasks: 0, validations: 0, evidences: 0, runs: 2,
-      usage: { total_tokens: known(100), cost: { ...known(10), currency: "BRL" } },
-    };
-    const operations = {
-      filters: { from: null, to: null }, summary: { task_count: 0 }, prds: [], specs: [],
-    } as unknown as OperationsProjection;
-    const partial = buildCostSummaryProjection({
-      periods: { daily: { "2026-08-12": period } },
-      cost_monitor_daily_duration: {
-        "2026-08-12": { known_sum: 60_000, eligible_runs: 2, known_runs: 1 },
-      },
-    }, operations, "BRL", null).groups.daily[0]!;
-    expect(partial).toMatchObject({ total_tokens: 100, estimated_brl: 10, duration_ms: 60_000 });
-    expect(partial.duration).toMatchObject({ known_sum: 60_000, unknown: 1, complete: false });
-
-    const observedZero = buildCostSummaryProjection({
-      periods: { daily: { "2026-08-12": { ...period, runs: 1 } } },
-      cost_monitor_daily_duration: {
-        "2026-08-12": { known_sum: 0, eligible_runs: 1, known_runs: 1 },
-      },
-    }, operations, "BRL", null).groups.daily[0]!;
-    expect(observedZero.duration_ms).toBe(0);
-  });
-  it("keeps monthly and annual duration unavailable when any financial day is incomplete", () => {
-    const known = (known_sum: number) => ({ known_sum, unknown: 0, complete: true, coverage_ratio: 1 });
-    const period = (tokens: number) => ({
-      prds: 0, specs: 0, tasks: 0, validations: 0, evidences: 0, runs: 1,
-      usage: { total_tokens: known(tokens), cost: { ...known(tokens), currency: "BRL" as const } },
-    });
-    const operations = { filters: { from: null, to: null }, summary: { task_count: 0 }, prds: [], specs: [] } as unknown as OperationsProjection;
-    const groups = buildCostSummaryProjection({
-      periods: { daily: { "2026-07-23": period(10), "2026-07-24": period(20) } },
-      cost_monitor_daily_duration: {
-        "2026-07-23": { known_sum: 20_000, eligible_runs: 1, known_runs: 1 },
-        "2026-07-24": { known_sum: 0, eligible_runs: 1, known_runs: 0 },
-      },
-    }, operations, "BRL", null).groups;
-    expect(groups.daily.map((row) => row.duration_ms)).toEqual([20_000, null]);
-    expect(groups.monthly[0]?.duration_ms).toBeNull();
-    expect(groups.annual[0]?.duration_ms).toBeNull();
-  });
 });