@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-multi-provider.test.ts

@@ -0,0 +1,691 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { expectFastCostPagesMatchCanonical } from "./sqlite-cost-fast-page-parity.test-support.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
+async function createSqliteTestRoot(): Promise<string> {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
+}
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("SQLite dashboard read model multi-provider", () => {
+  it("publishes a cache from a long fixture path with a short temporary filename", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await prepareMultiProviderFixture(root);
+    const cacheDirectory = join(root, `cache-${"x".repeat(Math.max(1, 175 - root.length - 6))}`);
+    const previousCacheDirectory = process.env.ZAIP_SQLITE_CACHE_DIR;
+    process.env.ZAIP_SQLITE_CACHE_DIR = cacheDirectory;
+    try {
+      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    } finally {
+      if (previousCacheDirectory === undefined) delete process.env.ZAIP_SQLITE_CACHE_DIR;
+      else process.env.ZAIP_SQLITE_CACHE_DIR = previousCacheDirectory;
+    }
+  });
+
+  it("keeps a multi-provider and multi-model Run visible to both filtered financial and duration facts", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    await rebuildSqliteReadModel(root);
+    const aggregateDatabase = new DatabaseSync(
+      resolve(root, ".local/dashboard-sqlite/read-model.sqlite"),
+      {
+        readOnly: true,
+      },
+    );
+    try {
+      const aggregates = aggregateDatabase
+        .prepare(`SELECT
+        json_extract(payload_json, '$.dimension') AS dimension,
+        json_extract(payload_json, '$.key') AS key,
+        json_extract(payload_json, '$.schema_version') AS schema_version,
+        json_extract(payload_json, '$.total_cost_brl') AS total_cost_brl
+        FROM zaip_aios_activities
+        WHERE payload_type = 'cost_dimension_aggregate_v1'`)
+        .all();
+      expect(aggregates).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            dimension: "provider",
+            key: "openai",
+            schema_version: 1,
+            total_cost_brl: 505,
+          }),
+          expect.objectContaining({
+            dimension: "model",
+            key: "gpt-a",
+            schema_version: 1,
+            total_cost_brl: 505,
+          }),
+        ]),
+      );
+      expect(aggregates.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
+    } finally {
+      aggregateDatabase.close();
+    }
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expectFastCostPagesMatchCanonical(root, filesystem);
+    expect(
+      filesystem.viewPage("cost_monitor_daily", { from: "2026-08-04", to: "2026-08-04" }).rows[0],
+    ).toMatchObject({ total_tokens: 1_030, total_cost_brl: 515 });
+    // The public overview view backs /api/v2/sqlite-views. It must not leak
+    // Cost Monitor retains all measurable financial activities, including
+    // historical/unassisted telemetry without an Agent Invocation id.
+    const publicOverview = filesystem.viewPage("cost_monitor_overview_view", {});
+    expect(publicOverview.rows).toHaveLength(3);
+    expect(publicOverview.rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          period_kind: "day",
+          total_run_count: 3,
+          invocation_count: 3,
+          total_tokens: 1_030,
+          total_cost_brl: 515,
+        }),
+        expect.objectContaining({
+          period_kind: "month",
+          total_run_count: 3,
+          invocation_count: 3,
+          total_tokens: 1_030,
+          total_cost_brl: 515,
+        }),
+        expect.objectContaining({
+          period_kind: "year",
+          total_run_count: 3,
+          invocation_count: 3,
+          total_tokens: 1_030,
+          total_cost_brl: 515,
+        }),
+      ]),
+    );
+    const allAgentGroups = filesystem.viewPage("cost_monitor_zaip_agents", {
+      limit: 20,
+      offset: 0,
+    });
+    const allCostTotals = publicOverview.rows.find((row) => row.period_kind === "day");
+    if (allCostTotals === undefined) throw new Error("Expected the daily Cost Monitor overview");
+    expect(
+      allAgentGroups.rows.reduce((total, row) => total + Number(row.invocation_count ?? 0), 0),
+    ).toBe(allCostTotals.total_run_count);
+    expect(
+      allAgentGroups.rows.reduce((total, row) => total + Number(row.total_tokens ?? 0), 0),
+    ).toBe(allCostTotals?.total_tokens);
+    expect(
+      allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_brl ?? 0), 0),
+    ).toBe(allCostTotals?.total_cost_brl);
+    expect(
+      allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_usd ?? 0), 0),
+    ).toBe(allCostTotals.total_cost_usd);
+    // Shared Cost Tempo is factual at the activity grain. It remains available
+    // in the agent-table total even where a multi-dimension invocation cannot
+    // be assigned to an individual Agent row.
+    expect(allCostTotals.cost_monitor_total_duration).toBe(120_000);
+    expect(allAgentGroups.totals).toMatchObject({
+      invocation_count: allCostTotals.total_run_count,
+      total_duration: 120_000,
+      total_tokens: allCostTotals.total_tokens,
+      total_cost_usd: allCostTotals.total_cost_usd,
+      total_cost_brl: allCostTotals.total_cost_brl,
+    });
+    for (const [providers, models] of [
+      [["openai"], ["gpt-a"]],
+      [["anthropic"], ["claude-b"]],
+    ] as const) {
+      const rows = filesystem.invocationCostRows({ from: null, to: null, providers, models });
+      expect(rows).toHaveLength(1);
+      // Membership is segment-based; once the invocation matches, its
+      // canonical invocation totals remain intact rather than being split.
+      expect(rows[0]).toMatchObject({ total_tokens: 30, cost_brl: 15 });
+      expect([
+        ...filesystem.executionDurationByDay({ from: null, to: null, providers, models }).values(),
+      ]).toEqual([60_000]);
+      expect([
+        ...filesystem.canonicalRunCountByDay({ from: null, to: null, providers, models }).values(),
+      ]).toEqual([1]);
+      for (const view of [
+        "cost_monitor_daily",
+        "cost_monitor_monthly",
+        "cost_monitor_annual",
+      ] as const) {
+        const page = filesystem.viewPage(view, {
+          provider: providers[0],
+          model: models[0],
+          limit: 20,
+          offset: 0,
+        });
+        expect(page.rows[0]).toMatchObject({
+          total_run_count: 1,
+          total_tokens: 30,
+          total_cost_brl: 15,
+        });
+      }
+      const agents = filesystem.viewPage("cost_monitor_zaip_agents", {
+        provider: providers[0],
+        model: models[0],
+        query: "agent",
+      });
+      const financialRows = filesystem.costMonitorFinancialActivityRows({
+        from: null,
+        to: null,
+        providers,
+        models,
+      });
+      const financialTotals = financialRows.reduce<{
+        invocation_count: number;
+        total_tokens: number;
+        total_cost_brl: number;
+      }>(
+        (total, row) => ({
+          invocation_count: total.invocation_count + 1,
+          total_tokens: total.total_tokens + Number(row.total_tokens ?? 0),
+          total_cost_brl: total.total_cost_brl + Number(row.cost_brl ?? 0),
+        }),
+        { invocation_count: 0, total_tokens: 0, total_cost_brl: 0 },
+      );
+      expect(agents.rows[0]).toMatchObject({
+        key: "agent",
+        persona: "ana",
+        job: "quality_engineer",
+        task_count: 1,
+        ...financialTotals,
+      });
+      expect(agents.totals).toMatchObject(financialTotals);
+    }
+    const crossed = { from: null, to: null, providers: ["openai"], models: ["claude-b"] };
+    expect(filesystem.invocationCostRows(crossed)).toHaveLength(0);
+    expect([...filesystem.executionDurationByDay(crossed).values()]).toEqual([]);
+    expect([...filesystem.canonicalRunCountByDay(crossed).values()]).toEqual([]);
+    expect(
+      filesystem.viewPage("cost_monitor_agent_invocations", {
+        provider: "openai",
+        model: "claude-b",
+      }).total_count,
+    ).toBe(0);
+    expect(
+      filesystem.viewPage("cost_monitor_zaip_agents", { provider: "openai", model: "claude-b" })
+        .total_count,
+    ).toBe(0);
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+    ] as const) {
+      // Lifecycle buckets can remain present independently, but the crossed
+      // pair must contribute no invocation financial or Run facts.
+      const row = filesystem.viewPage(view, { provider: "openai", model: "claude-b" }).rows[0];
+      expect(row).toMatchObject({
+        total_run_count: 0,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      });
+    }
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+    ] as const) {
+      const originFiltered = filesystem.viewPage(view, { origin: "task" });
+      expect(originFiltered.rows[0]).toMatchObject({
+        prd_count: null,
+        spec_count: null,
+        task_count: null,
+        validation_count: null,
+        evidence_count: null,
+      });
+      expect(filesystem.viewPage(view, { workType: "new" }).total_count).toBe(0);
+    }
+    expect(filesystem.viewPage("cost_monitor_zaip_agents", { priority: "high" })).toMatchObject({
+      total_count: 0,
+      rows: [],
+    });
+    const providerGroups = filesystem.viewPage("cost_monitor_providers", { limit: 20, offset: 0 });
+    expect(providerGroups.rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: "openai", total_tokens: 1_010, total_cost_brl: 505 }),
+        expect.objectContaining({ key: "anthropic", total_tokens: 20, total_cost_brl: 10 }),
+      ]),
+    );
+    expect(providerGroups.rows.map((row) => row.key)).toEqual(
+      expect.arrayContaining(["unavailable"]),
+    );
+    expect(
+      filesystem
+        .viewPage("cost_monitor_providers", { provider: "openai", model: "gpt-a" })
+        .rows.find((row) => row.key === "openai"),
+    ).toMatchObject({ total_tokens: 10, total_cost_brl: 5 });
+    expect(
+      filesystem.viewPage("cost_monitor_providers", { provider: "openai", model: "claude-b" }),
+    ).toMatchObject({ total_count: 0, rows: [] });
+    // A source segment can prove its financial facts, but an invocation with
+    // multiple observed providers cannot prove a provider-specific elapsed
+    // time. It must not manufacture a "mixed" bucket for that remainder.
+    const queriedProviderRows = filesystem.viewPage("cost_monitor_providers", {
+      query: "openai",
+    }).rows;
+    expect(queriedProviderRows).toEqual([
+      expect.objectContaining({ key: "openai", total_tokens: 10, total_cost_brl: 5 }),
+    ]);
+    const modelGroups = filesystem.viewPage("cost_monitor_models", { limit: 20, offset: 0 });
+    expect(modelGroups.rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: "gpt-a", total_tokens: 1_010, total_cost_brl: 505 }),
+        expect.objectContaining({ key: "claude-b", total_tokens: 20, total_cost_brl: 10 }),
+      ]),
+    );
+    // First-fold transport is aggregate-only, but its overview chart must
+    // retain the segment-backed model rows instead of falling back to the
+    // empty availability metadata.
+    expect(filesystem.costMonitorSummaryAggregate({ from: null, to: null }).model_groups).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: "gpt-a", total_tokens: 1_010, estimated_brl: 505 }),
+        expect.objectContaining({ key: "claude-b", total_tokens: 20, estimated_brl: 10 }),
+      ]),
+    );
+    expect(modelGroups.rows.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
+    const modelTotals = modelGroups.rows.reduce<{
+      invocations: number;
+      tasks: number;
+      duration: number;
+      tokens: number;
+      brl: number;
+    }>(
+      (total, row) => ({
+        invocations: total.invocations + Number(row.invocation_count ?? 0),
+        tasks: total.tasks + Number(row.task_count ?? 0),
+        duration: total.duration + Number(row.total_duration ?? 0),
+        tokens: total.tokens + Number(row.total_tokens ?? 0),
+        brl: total.brl + Number(row.total_cost_brl ?? 0),
+      }),
+      { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
+    );
+    expect(modelTotals).toEqual({
+      invocations: 2,
+      tasks: 3,
+      duration: 60_000,
+      tokens: 1030,
+      brl: 515,
+    });
+    expect(filesystem.viewPage("cost_monitor_models", { query: "gpt-a" }).rows).toHaveLength(1);
+    expect(
+      filesystem.viewPage("cost_monitor_models", { provider: "openai", model: "gpt-a" }).rows[0],
+    ).toMatchObject({ key: "gpt-a", total_tokens: 1010, total_cost_brl: 505 });
+    expect(
+      filesystem.viewPage("cost_monitor_models", { provider: "openai", model: "claude-b" }),
+    ).toMatchObject({ total_count: 0, rows: [] });
+    expect(filesystem.viewPage("cost_monitor_models", { priority: "high" })).toMatchObject({
+      total_count: 0,
+      rows: [],
+    });
+    const unavailable = {
+      from: null,
+      to: null,
+      providers: ["unavailable"],
+      models: ["unavailable"],
+    };
+    const unavailableRows = filesystem.invocationCostRows(unavailable);
+    expect(unavailableRows).toHaveLength(1);
+    // Observed zero telemetry stays zero, while the missing provider/model
+    // attribute selects this segment rather than a literal sentinel value.
+    expect(unavailableRows[0]).toMatchObject({ total_tokens: 0, cost_brl: 0 });
+    // Execution-duration is an Operations compatibility aggregate and still
+    // includes the unassisted canonical Run. Cost Monitor retains its
+    // measurable financial activity as an unavailable historical fact.
+    expect([...filesystem.executionDurationByDay(unavailable).values()]).toEqual([60_000]);
+    expect([...filesystem.canonicalRunCountByDay(unavailable).values()]).toEqual([2]);
+    const unavailableInvocation = filesystem.viewPage("cost_monitor_agent_invocations", {
+      provider: "unavailable",
+      model: "unavailable",
+    });
+    expect(unavailableInvocation).toMatchObject({ total_count: 1 });
+    expect(unavailableInvocation.rows[0]).toMatchObject({ input_tokens: 0 });
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+    ] as const) {
+      const row = filesystem.viewPage(view, { provider: "unavailable", model: "unavailable" })
+        .rows[0];
+      expect(row).toMatchObject({ total_run_count: 2, total_tokens: 1_000, total_cost_brl: 500 });
+    }
+
+    filesystem.close();
+    const sameModelStarted = {
+      ...started,
+      event_id: "RUN-SAME-MODEL:1",
+      run_id: "RUN-SAME-MODEL",
+      occurred_at: "2026-08-05T12:00:00.000Z",
+      client_turn_id: "same-model",
+      conversation_id: "CONV-SAME-MODEL",
+      execution_id: "EXEC-SAME-MODEL",
+      task_id: "TASK-SAME-MODEL",
+      agent_invocation_id: "AINV-SAME-MODEL",
+      root_agent_invocation_id: "AINV-SAME-MODEL",
+      provider: "mixed",
+      model: "gpt-a",
+    };
+    const sameModelUsage = (sequence: number, provider: string, tokens: number, brl: number) => ({
+      ...usage(sequence, provider, "gpt-a", tokens, brl),
+      event_id: `RUN-SAME-MODEL:${sequence}`,
+      run_id: "RUN-SAME-MODEL",
+      occurred_at: "2026-08-05T12:00:01.000Z",
+      source_started_at: "2026-08-05T12:00:00.000Z",
+      source_finished_at: "2026-08-05T12:01:00.000Z",
+    });
+    const sameModelFinished = {
+      ...finished,
+      event_id: "RUN-SAME-MODEL:4",
+      run_id: "RUN-SAME-MODEL",
+      sequence: 4,
+      occurred_at: "2026-08-05T12:01:00.000Z",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-SAME-MODEL.jsonl"),
+      `${[sameModelStarted, sameModelUsage(2, "openai", 3, 1.5), sameModelUsage(3, "anthropic", 4, 2), sameModelFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    const durationRun = (
+      id: string,
+      day: string,
+      duration: number | null,
+      provenance: "reconciled" | "estimated",
+    ) => {
+      const start = {
+        ...sameModelStarted,
+        event_id: `${id}:1`,
+        run_id: id,
+        occurred_at: `${day}T12:00:00.000Z`,
+        client_turn_id: id,
+        conversation_id: `CONV-${id}`,
+        execution_id: `EXEC-${id}`,
+        task_id: `TASK-${id}`,
+        agent_invocation_id: `AINV-${id}`,
+        root_agent_invocation_id: `AINV-${id}`,
+      };
+      const measured = {
+        ...usage(
+          2,
+          "openai",
+          "gpt-a",
+          provenance === "estimated" ? 4_000_000 : 9,
+          provenance === "estimated" ? 0 : 4.5,
+        ),
+        event_id: `${id}:2`,
+        run_id: id,
+        occurred_at: `${day}T12:00:01.000Z`,
+        source_started_at: `${day}T12:00:00.000Z`,
+        source_finished_at: `${day}T12:01:00.000Z`,
+        ...(duration === null ? {} : { duration_ms: duration, duration_provenance: provenance }),
+      };
+      const end = {
+        ...finished,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: 3,
+        occurred_at: `${day}T12:01:00.000Z`,
+        ...(provenance === "estimated"
+          ? { duration_ms: null, duration_provenance: "unavailable" }
+          : {}),
+      };
+      return [start, measured, end];
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-RECONCILED-MODEL.jsonl"),
+      `${durationRun("RUN-RECONCILED-MODEL", "2026-08-06", 45_000, "reconciled")
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-ESTIMATED-MODEL.jsonl"),
+      `${durationRun("RUN-ESTIMATED-MODEL", "2026-08-07", null, "estimated")
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    const sharedTaskRun = (id: string, model: string, tokens: number, brl: number) => [
+      {
+        ...sameModelStarted,
+        event_id: `${id}:1`,
+        run_id: id,
+        occurred_at: "2026-08-08T12:00:00.000Z",
+        client_turn_id: id,
+        conversation_id: `CONV-${id}`,
+        execution_id: `EXEC-${id}`,
+        task_id: "TASK-CROSS-MODEL",
+        agent_invocation_id: `AINV-${id}`,
+        root_agent_invocation_id: `AINV-${id}`,
+        provider: "openai",
+        model,
+      },
+      {
+        ...usage(2, "openai", model, tokens, brl),
+        event_id: `${id}:2`,
+        run_id: id,
+        occurred_at: "2026-08-08T12:00:01.000Z",
+        source_started_at: "2026-08-08T12:00:00.000Z",
+        source_finished_at: "2026-08-08T12:01:00.000Z",
+      },
+      {
+        ...finished,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: 3,
+        occurred_at: "2026-08-08T12:01:00.000Z",
+      },
+    ];
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-TASK-GPT.jsonl"),
+      `${sharedTaskRun("RUN-TASK-GPT", "gpt-a", 5, 2.5)
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-TASK-CLAUDE.jsonl"),
+      `${sharedTaskRun("RUN-TASK-CLAUDE", "claude-b", 6, 3)
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    const subrunStarted = {
+      ...sameModelStarted,
+      event_id: "RUN-PROVIDER-SUBRUN:1",
+      run_id: "RUN-PROVIDER-SUBRUN",
+      occurred_at: "2026-08-09T12:00:00.000Z",
+      client_turn_id: "provider-subrun",
+      conversation_id: "CONV-PROVIDER-SUBRUN",
+      execution_id: "EXEC-PROVIDER-SUBRUN",
+      task_id: "TASK-PROVIDER-SUBRUN",
+      agent_invocation_id: "AINV-PROVIDER-SUBRUN",
+      root_agent_invocation_id: "AINV-SAME-MODEL",
+      parent_agent_invocation_id: "AINV-SAME-MODEL",
+      parent_run_id: "RUN-SAME-MODEL",
+      run_role: "subagent",
+      invocation_kind: "delegated",
+      delegation_depth: 1,
+      provider: "openai",
+      model: "gpt-a",
+    };
+    const subrunUsage = {
+      ...usage(2, "openai", "gpt-a", 8, 4),
+      event_id: "RUN-PROVIDER-SUBRUN:2",
+      run_id: "RUN-PROVIDER-SUBRUN",
+      occurred_at: "2026-08-09T12:00:01.000Z",
+      source_started_at: "2026-08-09T12:00:00.000Z",
+      source_finished_at: "2026-08-09T12:00:30.000Z",
+    };
+    const subrunFinished = {
+      ...finished,
+      event_id: "RUN-PROVIDER-SUBRUN:3",
+      run_id: "RUN-PROVIDER-SUBRUN",
+      sequence: 3,
+      occurred_at: "2026-08-09T12:00:30.000Z",
+      duration_ms: 30_000,
+      duration_provenance: "observed",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-PROVIDER-SUBRUN.jsonl"),
+      `${[subrunStarted, subrunUsage, subrunFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const sameModelFs = new SqliteReadModelFileSystem(root);
+    const modelRow = (filter: Record<string, string>) =>
+      sameModelFs
+        .viewPage("cost_monitor_models", { from: "2026-08-05", to: "2026-08-05", ...filter })
+        .rows.find((row) => row.key === "gpt-a");
+    expect(modelRow({ provider: "openai", model: "gpt-a" })).toMatchObject({
+      invocation_count: 1,
+      task_count: 1,
+      total_duration: 60_000,
+      total_tokens: 3,
+      total_cost_brl: 1.5,
+    });
+    expect(modelRow({ provider: "anthropic", model: "gpt-a" })).toMatchObject({
+      invocation_count: 1,
+      task_count: 1,
+      total_duration: 60_000,
+      total_tokens: 4,
+      total_cost_brl: 2,
+    });
+    expect(modelRow({})).toMatchObject({
+      invocation_count: 1,
+      task_count: 1,
+      total_duration: 60_000,
+      total_tokens: 7,
+      total_cost_brl: 3.5,
+    });
+    expect(
+      sameModelFs.viewPage("cost_monitor_models", {
+        from: "2026-08-05",
+        to: "2026-08-05",
+        provider: "openai",
+        model: "claude-b",
+      }),
+    ).toMatchObject({ total_count: 0, rows: [] });
+    for (const day of ["2026-08-06", "2026-08-07"]) {
+      const effective = sameModelFs
+        .invocationCostRows({ from: day, to: day })
+        .reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0);
+      const modelDuration = sameModelFs
+        .viewPage("cost_monitor_models", { from: day, to: day })
+        .rows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0);
+      expect(modelDuration).toBe(effective);
+    }
+    for (const day of ["2026-08-06", "2026-08-07"]) {
+      const population = sameModelFs.invocationCostRows({ from: day, to: day });
+      const providerRows = sameModelFs.viewPage("cost_monitor_providers", {
+        from: day,
+        to: day,
+      }).rows;
+      const providerTotals = providerRows.reduce<{
+        invocations: number;
+        tasks: number;
+        duration: number;
+        tokens: number;
+        brl: number;
+      }>(
+        (total, row) => ({
+          invocations: total.invocations + Number(row.invocation_count ?? 0),
+          tasks: total.tasks + Number(row.task_count ?? 0),
+          duration: total.duration + Number(row.total_duration ?? 0),
+          tokens: total.tokens + Number(row.total_tokens ?? 0),
+          brl: total.brl + Number(row.total_cost_brl ?? 0),
+        }),
+        { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
+      );
+      expect(providerTotals).toEqual({
+        invocations: population.length,
+        tasks: new Set(
+          population.map((row) => row.task_id).filter((id): id is string => typeof id === "string"),
+        ).size,
+        duration: population.reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0),
+        tokens: population.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
+        brl: population.reduce((sum, row) => sum + Number(row.cost_brl ?? 0), 0),
+      });
+    }
+    const sharedTaskRows = sameModelFs.viewPage("cost_monitor_models", {
+      from: "2026-08-08",
+      to: "2026-08-08",
+    }).rows;
+    expect(sharedTaskRows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: "gpt-a",
+          invocation_count: 1,
+          task_count: 1,
+          total_duration: 30_000,
+          total_tokens: 5,
+          total_cost_brl: 2.5,
+        }),
+        expect.objectContaining({
+          key: "claude-b",
+          invocation_count: 1,
+          task_count: 1,
+          total_duration: 30_000,
+          total_tokens: 6,
+          total_cost_brl: 3,
+        }),
+      ]),
+    );
+    expect(sharedTaskRows.map((row) => row.key)).not.toContain("mixed");
+    expect(sharedTaskRows.reduce((sum, row) => sum + Number(row.task_count ?? 0), 0)).toBe(2);
+    const subrunPopulation = sameModelFs.invocationCostRows({
+      from: "2026-08-09",
+      to: "2026-08-09",
+      providers: ["openai"],
+      models: ["gpt-a"],
+    });
+    const subrunProviderRows = sameModelFs.viewPage("cost_monitor_providers", {
+      from: "2026-08-09",
+      to: "2026-08-09",
+      provider: "openai",
+      model: "gpt-a",
+    }).rows;
+    const subrunProviderTotals = subrunProviderRows.reduce<{
+      invocations: number;
+      tasks: number;
+      duration: number;
+      tokens: number;
+      brl: number;
+    }>(
+      (total, row) => ({
+        invocations: total.invocations + Number(row.invocation_count ?? 0),
+        tasks: total.tasks + Number(row.task_count ?? 0),
+        duration: total.duration + Number(row.total_duration ?? 0),
+        tokens: total.tokens + Number(row.total_tokens ?? 0),
+        brl: total.brl + Number(row.total_cost_brl ?? 0),
+      }),
+      { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
+    );
+    expect(subrunProviderTotals).toEqual({
+      invocations: subrunPopulation.length,
+      tasks: new Set(
+        subrunPopulation
+          .map((row) => row.task_id)
+          .filter((id): id is string => typeof id === "string"),
+      ).size,
+      duration: subrunPopulation.reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0),
+      tokens: subrunPopulation.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
+      brl: subrunPopulation.reduce((sum, row) => sum + Number(row.cost_brl ?? 0), 0),
+    });
+    expect(
+      sameModelFs.viewPage("cost_monitor_providers", {
+        from: "2026-08-09",
+        to: "2026-08-09",
+        provider: "openai",
+        model: "claude-b",
+      }),
+    ).toMatchObject({ total_count: 0, rows: [] });
+    sameModelFs.close();
+  });
+});