@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -0,0 +1,956 @@
+import {
+  globalLegacyEffortDurationMs,
+  type OperationsProjection,
+} from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "./build-cost-summary-projection.js";
+
+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: [],
+    } 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" },
+          },
+        },
+      } },
+      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);
+
+    expect(projection).toMatchObject({
+      aggregate_only: true,
+      runs: [],
+      overview: { estimated_usd: 8.7, estimated_brl: 47.5 },
+    });
+    expect(projection.groups.daily[0]).toMatchObject({ estimated_usd: 8.7, estimated_brl: 47.5 });
+  });
+
+  it("prefers aggregate SQL usage without transporting Run facts", () => {
+    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 },
+      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),
+    };
+    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: [],
+    } 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);
+
+    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 });
+  });
+
+  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 summary = {
+      periods: { daily: {} },
+      run_metrics: [
+        run("CONV", "conversation", 10, 4, 5, 2, 1, 100),
+        run("PLAN", "planning", 20, 8, 7, 3, 2, 200),
+        run("EXEC", "execution", 30, 12, 9, 4, 3, 300),
+      ],
+    } 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: [],
+    } 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.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: [],
+    } 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,
+      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);
+
+    expect(projection.groups.models.map((row) => [row.key, row.estimated_brl])).toEqual([
+      ["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: [],
+    } 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,
+      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);
+
+    expect(projection.groups.models.map((row) => row.key)).toEqual(["gpt-real"]);
+  });
+
+  it("does not promote aggregate token and cost totals without canonical Run facts", () => {
+    const known = (known_sum: number, coverage_ratio = 1) => ({
+      known_sum,
+      unknown: coverage_ratio === 1 ? 0 : 1,
+      complete: coverage_ratio === 1,
+      coverage_ratio,
+    });
+    const period = (tasks: number, evidences: number, validations: number, runs: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks,
+      validations,
+      evidences,
+      runs,
+      usage: {
+        total_tokens: known(tasks * 100),
+        cost: { ...known(tasks * 2), currency: "BRL" },
+      },
+      duration: known(tasks * 1_000),
+      events: known(tasks * 3),
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-04": period(2, 3, 4, 2),
+          "2026-08-05": period(5, 6, 7, 5),
+        },
+      },
+      run_metrics: [
+        {
+          id: "ROOT-04",
+          started_at: "2026-08-04T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          agent: "agent-builder",
+          agent_name: "Builder",
+          provider: "openai",
+          model: "gpt-5.6",
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 2_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "ROOT-05",
+          started_at: "2026-08-05T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 5_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "CHILD-05",
+          started_at: "2026-08-05T13:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: "ROOT-05",
+          status: null,
+          duration_ms: 99_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+    };
+    const operations = {
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: {
+        task_count: 7,
+        overview_metrics: { task_count: 7 },
+        usage: {} as OperationsProjection["summary"]["usage"],
+      },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", 5);
+
+    expect(projection).toMatchObject({
+      aggregate_only: true,
+      runs: [],
+      overview: {
+        task_count: 7,
+        run_count: 3,
+        event_count: 0,
+        total_tokens: null,
+        estimated_brl: null,
+      },
+    });
+    expect(projection.groups.agents).toEqual(
+      expect.arrayContaining([expect.objectContaining({ label: "Builder" })]),
+    );
+    expect(projection.groups.providers).toEqual(
+      expect.arrayContaining([expect.objectContaining({ label: "openai" })]),
+    );
+    expect(projection.groups.models).toEqual(
+      expect.arrayContaining([expect.objectContaining({ label: "gpt-5.6" })]),
+    );
+    // High-cardinality lifecycle dimensions are intentionally fetched from
+    // their paginated read-model routes only after a user opens that tab.
+    expect(projection.groups.conversations).toEqual([]);
+    expect(projection.groups.tasks).toEqual([]);
+    const filteredDimensions = buildCostSummaryProjection(
+      summary,
+      { ...operations, filters: { from: "2026-08-05", to: "2026-08-05" } },
+      "BRL",
+      5,
+    );
+    expect(filteredDimensions.groups.daily.reduce((total, row) => total + row.run_count, 0)).toBe(
+      2,
+    );
+    expect(projection.groups.monthly[0]).toMatchObject({
+      key: "2026-08",
+      task_count: 7,
+      evidence_count: 9,
+      test_count: 11,
+      duration_ms: 7_000,
+      total_tokens: null,
+      estimated_brl: null,
+    });
+    // Effective root timing is not an invocation observation. The phase metric
+    // stays unavailable until the SQLite source-duration fact is present.
+    expect(projection.usage.execution.duration_ms).toBeNull();
+    const firstRun = summary.run_metrics?.[0];
+    if (firstRun === undefined) throw new Error("fixture requires a compact Run");
+    const observedZero = buildCostSummaryProjection(
+      { ...summary, run_metrics: [{ ...firstRun, source_duration_ms: 0 }] },
+      operations,
+      "BRL",
+      5,
+    );
+    expect(observedZero.usage.execution.duration_ms).toBe(0);
+  });
+
+  it("derives known token and cost Runs from the filtered period population", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-06": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 3,
+            usage: {
+              total_tokens: { known_sum: 120, unknown: 1, complete: false, coverage_ratio: 2 / 3 },
+              cost: {
+                known_sum: 4,
+                unknown: 1,
+                complete: false,
+                coverage_ratio: 2 / 3,
+                currency: "BRL",
+              },
+            },
+          },
+        },
+      },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const row = buildCostSummaryProjection(summary, operations, "BRL", 5).groups.daily[0]!;
+
+    expect(row.coverage_counts).toEqual({
+      source: "period_summary",
+      granularity: "unavailable",
+      events: null,
+      tokens: null,
+      usd: null,
+      brl: null,
+      metrics: {
+        duration: { eligible_runs: 3, known_runs: 3, unknown_runs: 0 },
+        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 },
+      },
+    });
+    expect(row.total_tokens).toBe(120);
+    expect(row.estimated_brl).toBe(4);
+    expect(row.coverage).toEqual({ events: 3, tokens: 2, usd: 2, brl: 2 });
+  });
+
+  it("keeps aggregate-only summary independent from Run-phase dimensions", () => {
+    const summary: CostSummarySource = {
+      periods: { daily: {} },
+      run_metrics: [
+        {
+          id: "CONVERSATION",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "conversation",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: 10,
+          cost: 2,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "PLANNING",
+          started_at: "2026-08-07T13:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "planning",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: 20,
+          cost: 3,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "EXECUTION",
+          started_at: "2026-08-07T14:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: 30,
+          cost: 4,
+          currency: "BRL",
+          events: 1,
+        },
+      ],
+    };
+    const operations = {
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 0, usage: {} },
+      prds: [],
+      specs: [],
+      tasks: [],
+    } as unknown as OperationsProjection;
+
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
+    expect(projection.runs).toEqual([]);
+    expect(projection.groups.daily).not.toEqual([]);
+    expect(projection.groups.agents).toEqual(
+      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);
+  });
+
+  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();
+  });
+});