@zaip-ai/cli 2.2.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts

@@ -0,0 +1,739 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { expectPersistedFirstFoldCaches } from "./sqlite-read-model-cache.test-support.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 () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await Promise.all(
+    roots
+      .splice(0)
+      .map((root) =>
+        import("node:fs/promises").then(({ rm }) => rm(root, { recursive: true, force: true })),
+      ),
+  );
+});
+describe("SQLite dashboard read model", () => {
+  it("counts every root execution day and returns task duration leaders", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    for (const kind of ["tasks", "specs", "prds"])
+      await mkdir(join(root, ".agents", "records", kind, "2026", "08"), { recursive: true });
+    await mkdir(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "evidence"),
+      { recursive: true },
+    );
+    await mkdir(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-ART",
+        "artifacts",
+        "validations",
+      ),
+      { recursive: true },
+    );
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "framework.lock.yaml"),
+      "lock_version: 1\nframework:\n  version: 2.5.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+      "utf8",
+    );
+    const run = (
+      id: string,
+      day: string,
+      task: string,
+      duration: number,
+      time = "12:00:00.000Z",
+      spec: string | null = null,
+      prd: string | null = null,
+    ) => [
+      {
+        schema_version: 2,
+        event_id: `${id}:1`,
+        run_id: id,
+        sequence: 1,
+        occurred_at: `${day}T${time}`,
+        type: "run.started",
+        attribution_status: "attributed",
+        phase: "execution",
+        run_role: "orchestrator",
+        run_purpose: "execution",
+        requires_finalizer: false,
+        execution_kind: "delivery",
+        execution_eligibility: ["delivery"],
+        entrypoint: "task",
+        work_type: "new",
+        storage_mode: "tracked_sanitized",
+        client: "codex",
+        agent: "agent",
+        agent_name: "agent",
+        provider: "openai",
+        model: "gpt-5",
+        reasoning_effort: null,
+        client_thread_id: id,
+        client_turn_id: id,
+        conversation_id: `CONV-${id}`,
+        execution_id: `EXEC-${id}`,
+        task_id: task,
+        spec_id: spec,
+        prd_id: prd,
+        change_id: null,
+        parent_run_id: null,
+        continuation_of_run_id: null,
+        retry_of_run_id: null,
+        agent_invocation_id: `AINV-${id}`,
+        root_agent_invocation_id: `AINV-${id}`,
+        parent_agent_invocation_id: null,
+        invocation_kind: "orchestrator",
+        delegation_depth: 0,
+      },
+      {
+        schema_version: 2,
+        event_id: `${id}:2`,
+        run_id: id,
+        sequence: 2,
+        occurred_at: `${day}T12:00:01.000Z`,
+        type: "usage.recorded",
+        phase: "execution",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: 1,
+          cached_input: 0,
+          output: 1,
+          reasoning: 0,
+          total: 2,
+          source: "provider_reported",
+        },
+        cost: { usd: 1, brl: 5, fx_rate: 5 },
+        provider: "openai",
+        model: "gpt-5",
+        source_segment_key: id,
+        model_call_id: `MCALL-${id}`,
+        runtime: { reasoning_effort: null, service_tier: null },
+        supersedes_event_id: null,
+        duration_ms: null,
+        duration_provenance: null,
+      },
+      {
+        schema_version: 2,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: 3,
+        occurred_at: `${day}T12:00:02.000Z`,
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: duration,
+        duration_provenance: "observed",
+      },
+    ];
+    for (const [id, records] of [
+      [
+        "RUN-R1",
+        run("RUN-R1", "2026-08-01", "TASK-A", 600_000, "12:00:00.000Z", "SPEC-A", "PRD-A"),
+      ],
+      [
+        "RUN-R2",
+        run("RUN-R2", "2026-08-02", "TASK-B", 1_200_000, "12:00:00.000Z", "SPEC-B", "PRD-A"),
+      ],
+      [
+        "RUN-R3",
+        run("RUN-R3", "2026-08-02", "TASK-B", 1_200_000, "12:10:00.000Z", "SPEC-B", "PRD-A"),
+      ],
+    ] as const) {
+      await writeFile(
+        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
+        `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+        "utf8",
+      );
+    }
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-ART",
+        "artifacts",
+        "evidence",
+        "EVD-1.md",
+      ),
+      "---\nid: EVD-1\nobserved_at: 2026-08-01T12:00:00.000Z\n---\n# Evidence\n",
+      "utf8",
+    );
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-ART",
+        "artifacts",
+        "validations",
+        "VAL-1.md",
+      ),
+      "---\nid: VAL-1\nexecuted_at: 2026-08-02T12:00:00.000Z\n---\n# Validation\n",
+      "utf8",
+    );
+    for (const [kind, id] of [
+      ["tasks", "TASK-NO-RUN"],
+      ["specs", "SPEC-NO-RUN"],
+      ["prds", "PRD-NO-RUN"],
+    ] as const)
+      await writeFile(
+        join(root, ".agents", "records", kind, "2026", "08", `${id}.md`),
+        `---\nid: ${id}\ntitle: ${id}\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# ${id}\n`,
+        "utf8",
+      );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.firstFoldAggregate({ from: null, to: null }).execution_day_count).toBe(2);
+    expect(filesystem.firstFoldAggregate({ from: null, to: null }).duration_ms).toBe(2_400_000);
+    expect(filesystem.topTasks({ from: null, to: null })).toMatchObject([
+      { task_id: "TASK-B", duration_ms: 1_800_000 },
+      { task_id: "TASK-A", duration_ms: 600_000 },
+    ]);
+    expect(filesystem.summaryPage("task", { from: null, to: null }, 0, 50).rows).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-B",
+        invocation_count: 2,
+        total_duration: 1_800_000,
+        total_tokens: 4,
+        total_cost_brl: 10,
+      }),
+    );
+    expect(filesystem.summaryPage("spec", { from: null, to: null }, 0, 50).rows).toContainEqual(
+      expect.objectContaining({
+        id: "SPEC-B",
+        invocation_count: 2,
+        total_duration: 1_800_000,
+        total_tokens: 4,
+        total_cost_brl: 10,
+      }),
+    );
+    expect(filesystem.summaryPage("prd", { from: null, to: null }, 0, 50).rows).toContainEqual(
+      expect.objectContaining({
+        id: "PRD-A",
+        invocation_count: 3,
+        total_duration: 2_400_000,
+        total_tokens: 6,
+        total_cost_brl: 15,
+      }),
+    );
+    expect(filesystem.summaryPage("task", { from: null, to: null }, 0, 50).rows).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-NO-RUN",
+        invocation_count: null,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      }),
+    );
+    const allTime = filesystem.firstFoldAllTime();
+    expectPersistedFirstFoldCaches(root, allTime, filesystem.firstFoldBoardAllTime());
+    expect(allTime.aggregate).toMatchObject({
+      start_day: "2026-08-01",
+      end_day: "2026-08-03",
+      task_count: 3,
+      spec_count: 3,
+      prd_count: 2,
+      total_run_count: 3,
+      duration_ms: 2_400_000,
+      total_tokens: 6,
+      cost_brl: 15,
+      execution_day_count: 2,
+    });
+    expect(allTime.task_status_counts).toEqual({ draft: 3 });
+    // The served quick projection uses this deliberately lean subset. It must
+    // remain factually identical to the rich projection for the six cards and
+    // two first-fold charts, while leaving rankings and macro metrics lazy.
+    const viewport = filesystem.firstFoldViewportAllTime();
+    expect(viewport.aggregate).toEqual(allTime.aggregate);
+    expect(viewport.task_status_counts).toEqual(allTime.task_status_counts);
+    expect(viewport.task_risk_counts).toEqual(allTime.task_risk_counts);
+    expect(allTime.top_tasks).toMatchObject([
+      { rank: 1, task_id: "TASK-B", total_duration_ms: 1_800_000 },
+      { rank: 2, task_id: "TASK-A", total_duration_ms: 600_000 },
+    ]);
+    expect(filesystem.firstFoldTopTasksAllTime()).toEqual(allTime.top_tasks);
+    expect(
+      projectAllTimeTopTasks([
+        {
+          task_id: "TASK-NO-USAGE",
+          total_duration_ms: null,
+          total_tokens: null,
+          total_cost_usd: null,
+          total_cost_brl: null,
+          total_run_count: 1,
+        },
+      ]),
+    ).toEqual([
+      {
+        task_id: "TASK-NO-USAGE",
+        duration_ms: null,
+        total_tokens: null,
+        total_cost_usd: null,
+        cost_brl: null,
+        run_count: 1,
+      },
+    ]);
+    const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+    const allTimeQuick = await app.request("/api/v2/operations?scope=quick", {
+      headers: { "x-zaip-session": "test-session" },
+    });
+    const boundedQuick = await app.request(
+      "/api/v2/operations?scope=quick&from=2026-08-02&to=2026-08-02",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    const topTasks = (await allTimeQuick.json()) as {
+      summary: { overview_metrics?: { top_tasks?: unknown[] } };
+    };
+    const boundedTopTasks = (await boundedQuick.json()) as {
+      summary: { overview_metrics?: { top_tasks?: unknown[] } };
+    };
+    expect(topTasks.summary.overview_metrics?.top_tasks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          task_id: "TASK-B",
+          duration_ms: 1_800_000,
+          total_tokens: 4,
+          cost_brl: 10,
+        }),
+      ]),
+    );
+    expect(boundedTopTasks.summary.overview_metrics?.top_tasks).toEqual([
+      expect.objectContaining({
+        task_id: "TASK-B",
+        duration_ms: 1_800_000,
+        total_tokens: 4,
+        cost_brl: 10,
+      }),
+    ]);
+    // A new calendar month after this immutable snapshot has no factual rows.
+    // It must be a fast exact empty projection, not a slow scan caused by the
+    // default date range changing at midnight on the first day of the month.
+    const nextMonthQuick = await app.request(
+      "/api/v2/operations?scope=quick&from=2026-09-01&to=2026-09-01",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    const nextMonth = (await nextMonthQuick.json()) as {
+      summary: {
+        run_count: number;
+        task_count: number;
+        overview_metrics: { tokens: number | null; duration_ms: number | null };
+      };
+    };
+    expect(nextMonth.summary).toMatchObject({
+      run_count: 0,
+      task_count: 0,
+      overview_metrics: { tokens: null, duration_ms: null },
+    });
+    expect(allTime.macro_metrics.specs).toMatchObject({
+      entity_count: 3,
+      status_counts: { planning: 3 },
+      classification_counts: { structured: 2 },
+      total_run_count: 3,
+      total_duration_ms: 2_400_000,
+      total_tokens: 6,
+      total_cost_brl: 15,
+      average_duration_ms: 800_000,
+    });
+    expect(allTime.macro_metrics.specs.top_entities.slice(0, 2)).toMatchObject([
+      { rank: 1, entity_id: "SPEC-B", total_duration_ms: 1_800_000 },
+      { rank: 2, entity_id: "SPEC-A", total_duration_ms: 600_000 },
+    ]);
+    expect(allTime.macro_metrics.prds).toMatchObject({
+      entity_count: 2,
+      status_counts: { definition: 2 },
+      classification_counts: { structured: 1 },
+      total_run_count: 3,
+      total_duration_ms: 2_400_000,
+      total_tokens: 6,
+      total_cost_brl: 15,
+      average_duration_ms: 1_200_000,
+    });
+    const operationDays = filesystem.dailyPeriods({ from: null, to: null });
+    expect(Object.keys(operationDays)).toEqual(["2026-08-01", "2026-08-02", "2026-08-03"]);
+    expect(operationDays["2026-08-02"]).toMatchObject({
+      runs: 2,
+      specs: 1,
+      tasks: 1,
+      validations: 1,
+      evidences: 0,
+      usage: {
+        total_tokens: { known_sum: 4, unknown: 0 },
+        cost: { known_sum: 10, unknown: 0 },
+      },
+      duration: { known_sum: 1_800_000, unknown: 0 },
+    });
+    expect(filesystem.viewPage("operations_daily", { limit: 50 }).rows).toContainEqual(
+      expect.objectContaining({
+        day: "2026-08-02",
+        task_count: 1,
+        spec_count: 1,
+        validation_count: 1,
+        evidence_count: 0,
+        total_run_count: 2,
+        operations_total_duration: 1_800_000,
+        total_tokens: 4,
+        total_cost_brl: 10,
+      }),
+    );
+    for (const [view, key] of [
+      ["operations_monthly", "2026-08"],
+      ["operations_annual", "2026"],
+    ] as const) {
+      expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
+        expect.objectContaining({
+          period_key: key,
+          prd_count: 2,
+          spec_count: 3,
+          task_count: 3,
+          validation_count: 1,
+          evidence_count: 1,
+          total_run_count: 3,
+          operations_total_duration: 2_400_000,
+          total_tokens: 6,
+          total_cost_brl: 15,
+        }),
+      );
+    }
+    for (const view of ["operations_monthly", "operations_annual"] as const) {
+      expect(
+        filesystem.viewPage(view, {
+          from: "2026-08-02T03:00:00.000Z",
+          to: "2026-08-02T23:59:59.999Z",
+          limit: 50,
+        }).rows,
+      ).toEqual([
+        expect.objectContaining({
+          start_day: "2026-08-02",
+          end_day: "2026-08-02",
+          total_run_count: 2,
+          invocation_count: 2,
+          operations_total_duration: 1_800_000,
+          total_tokens: 4,
+          total_cost_usd: 2,
+          total_cost_brl: 10,
+        }),
+      ]);
+    }
+    for (const [view, key, counts] of [
+      [
+        "cost_monitor_daily",
+        "2026-08-02",
+        { prd_count: 0, spec_count: 1, task_count: 1, validation_count: 1, evidence_count: 0 },
+      ],
+      [
+        "cost_monitor_monthly",
+        "2026-08",
+        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+      ],
+      [
+        "cost_monitor_annual",
+        "2026",
+        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+      ],
+    ] as const) {
+      expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
+        expect.objectContaining({ key, ...counts }),
+      );
+    }
+    expect(filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows).toContainEqual(
+      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 1 }),
+    );
+    expect(filesystem.viewPage("cost_monitor_monthly", { limit: 50 }).rows).toContainEqual(
+      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 3 }),
+    );
+    expect(filesystem.viewPage("cost_monitor_annual", { limit: 50 }).rows).toContainEqual(
+      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 3 }),
+    );
+    const annualCostPage = filesystem.viewPage("cost_monitor_annual", { limit: 50 });
+    const dailyCostRows = filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows;
+    const pagedDailyCostPage = filesystem.viewPage("cost_monitor_daily", { limit: 1 });
+    expect(pagedDailyCostPage).toMatchObject({
+      total_count: dailyCostRows.length,
+      rows: [expect.any(Object)],
+    });
+    expect(pagedDailyCostPage.totals).toMatchObject({
+      total_tokens: dailyCostRows.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
+      total_cost_brl: dailyCostRows.reduce((sum, row) => sum + Number(row.total_cost_brl ?? 0), 0),
+      total_duration: dailyCostRows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0),
+    });
+    expect(annualCostPage).toMatchObject({
+      total_count: 1,
+      rows: [expect.objectContaining({ key: "2026" })],
+    });
+    const annualCostRow = annualCostPage.rows[0];
+    if (annualCostRow === undefined) throw new Error("Expected the consolidated 2026 Cost row");
+    for (const metric of [
+      "prd_count",
+      "spec_count",
+      "task_count",
+      "validation_count",
+      "evidence_count",
+      "total_run_count",
+      "total_duration",
+      "duration_known",
+      "total_tokens",
+      "total_cost_usd",
+      "total_cost_brl",
+    ] as const) {
+      const observed = dailyCostRows
+        .map((row) => row[metric])
+        .filter((value): value is number => typeof value === "number");
+      expect(annualCostRow[metric]).toBe(
+        observed.length === 0 ? null : observed.reduce((sum, value) => sum + value, 0),
+      );
+    }
+    expect(
+      filesystem.viewPage("cost_monitor_daily", { limit: 50, provider: "openai" }).rows,
+    ).toContainEqual(
+      expect.objectContaining({
+        key: "2026-08-02",
+        prd_count: 0,
+        spec_count: 1,
+        task_count: 1,
+        validation_count: 1,
+        evidence_count: 0,
+      }),
+    );
+    for (const [view, entityCount] of [
+      ["cost_monitor_tasks", 2],
+      ["cost_monitor_specs", 3],
+      ["cost_monitor_prds", 2],
+      ["cost_monitor_conversations", 3],
+    ] as const) {
+      const page = filesystem.viewPage(view, { limit: 1 });
+      // The subtotal is computed before pagination and reconciles the full
+      // filtered population, rather than the single visible row.
+      expect(page).toMatchObject({ total_count: entityCount, rows: [expect.any(Object)] });
+      expect(page.totals).toEqual({
+        entity_count: entityCount,
+        invocation_count: 3,
+        total_duration: 2_400_000,
+        total_tokens: 6,
+        total_cost_usd: 3,
+        total_cost_brl: 15,
+      });
+    }
+    expect(
+      filesystem.viewPage("cost_monitor_tasks", {
+        from: "2026-08-02",
+        to: "2026-08-02",
+        query: "TASK-B",
+        limit: 1,
+      }).totals,
+    ).toEqual({
+      entity_count: 1,
+      invocation_count: 2,
+      total_duration: 1_800_000,
+      total_tokens: 4,
+      total_cost_usd: 2,
+      total_cost_brl: 10,
+    });
+    // The compact Cost Monitor tables share the canonical macro population
+    // with their big numbers.  A macro with no direct invocation must remain
+    // paginable and retain unavailable financial facts as null.
+    expect(
+      filesystem.viewPage("cost_monitor_specs", { query: "SPEC-NO-RUN", limit: 1 }),
+    ).toMatchObject({
+      total_count: 1,
+      totals: {
+        entity_count: 1,
+        invocation_count: 0,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      },
+      rows: [
+        expect.objectContaining({
+          id: "SPEC-NO-RUN",
+          title: "SPEC-NO-RUN",
+          invocation_count: 0,
+          total_duration: null,
+          total_tokens: null,
+          total_cost_brl: null,
+        }),
+      ],
+    });
+    expect(
+      filesystem.viewPage("cost_monitor_prds", { query: "PRD-NO-RUN", limit: 1 }),
+    ).toMatchObject({
+      total_count: 1,
+      totals: {
+        entity_count: 1,
+        invocation_count: 0,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      },
+      rows: [
+        expect.objectContaining({
+          id: "PRD-NO-RUN",
+          title: "PRD-NO-RUN",
+          invocation_count: 0,
+          total_duration: null,
+          total_tokens: null,
+          total_cost_brl: null,
+        }),
+      ],
+    });
+    for (const view of [
+      "cost_monitor_tasks",
+      "cost_monitor_specs",
+      "cost_monitor_prds",
+      "cost_monitor_conversations",
+    ] as const) {
+      const filtered = filesystem.viewPage(view, {
+        phase: "execution",
+        provider: "openai",
+        model: "gpt-5",
+        limit: 1,
+      });
+      // Dimensional membership and the subtotal share one pre-pagination
+      // invocation population for every compact lifecycle view.
+      expect(filtered.rows).toHaveLength(1);
+      expect(filtered.totals).toMatchObject({
+        invocation_count: 3,
+        total_tokens: 6,
+        total_cost_brl: 15,
+      });
+    }
+    expect(filesystem.viewPage("cost_monitor_tasks", { workType: "new", limit: 1 })).toMatchObject({
+      total_count: 0,
+      rows: [],
+    });
+    expect(filesystem.firstFoldAllTime()).toBe(allTime);
+    filesystem.close();
+
+    // Period membership follows the canonical macro day, not an invocation
+    // that happened on another day. Search accepts either the macro ID or
+    // title, and totals are still calculated before its one-row page.
+    await writeFile(
+      join(root, ".agents", "records", "specs", "2026", "08", "SPEC-CANONICAL-DAY.md"),
+      "---\nid: SPEC-CANONICAL-DAY\ntitle: Macro by canonical title\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# Macro\n",
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY.jsonl"),
+      `${run(
+        "RUN-CANONICAL-DAY",
+        "2026-08-02",
+        "TASK-CANONICAL-DAY",
+        1_000,
+        "12:30:00.000Z",
+        "SPEC-CANONICAL-DAY",
+      )
+        .map((record) => JSON.stringify(record))
+        .join("\n")}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY-LATE.jsonl"),
+      `${run(
+        "RUN-CANONICAL-DAY-LATE",
+        "2026-08-04",
+        "TASK-CANONICAL-DAY-LATE",
+        1_000,
+        "12:30:00.000Z",
+        "SPEC-CANONICAL-DAY",
+      )
+        .map((record) => JSON.stringify(record))
+        .join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const canonicalDayFilesystem = new SqliteReadModelFileSystem(root);
+    expect(
+      canonicalDayFilesystem.viewPage("cost_monitor_specs", {
+        from: "2026-08-03",
+        to: "2026-08-03",
+        query: "canonical title",
+        limit: 1,
+      }),
+    ).toMatchObject({
+      total_count: 1,
+      totals: { entity_count: 1, invocation_count: 0, total_tokens: null, total_cost_brl: null },
+      rows: [
+        expect.objectContaining({
+          id: "SPEC-CANONICAL-DAY",
+          invocation_count: 0,
+          total_tokens: null,
+          total_cost_brl: null,
+        }),
+      ],
+    });
+    expect(
+      canonicalDayFilesystem.viewPage("cost_monitor_specs", {
+        from: "2026-08-02",
+        to: "2026-08-02",
+        query: "SPEC-CANONICAL-DAY",
+        limit: 1,
+      }),
+    ).toMatchObject({ total_count: 0, rows: [] });
+    canonicalDayFilesystem.close();
+
+    // A large result set keeps its subtotal for all 270 matching Tasks while
+    // the page transports only 50 records.
+    for (let index = 0; index < 270; index += 1) {
+      const id = `RUN-PAGE-${index}`;
+      await writeFile(
+        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
+        `${run(id, "2026-08-04", `TASK-PAGE-${index}`, 1_000)
+          .map((record) => JSON.stringify(record))
+          .join("\n")}\n`,
+        "utf8",
+      );
+    }
+    await rebuildSqliteReadModel(root);
+    const pageFilesystem = new SqliteReadModelFileSystem(root);
+    const paged = pageFilesystem.viewPage("cost_monitor_tasks", {
+      from: "2026-08-04",
+      to: "2026-08-04",
+      query: "TASK-PAGE-",
+      offset: 50,
+      limit: 50,
+    });
+    expect(paged).toMatchObject({ total_count: 270, has_more: true });
+    expect(paged.rows).toHaveLength(50);
+    expect(paged.totals).toEqual({
+      entity_count: 270,
+      invocation_count: 270,
+      total_duration: 1_000,
+      total_tokens: 540,
+      total_cost_usd: 270,
+      total_cost_brl: 1_350,
+    });
+    pageFilesystem.close();
+  });
+});