@zaip-ai/cli 2.2.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-does-not-convert-delayed-historical-finalizer.test.ts

@@ -0,0 +1,706 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.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("does not convert a delayed historical finalizer into execution time", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-3:1",
+      run_id: "RUN-3",
+      sequence: 1,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      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: "thread",
+      client_turn_id: "turn",
+      conversation_id: "CONV-3",
+      execution_id: "EXEC-3",
+      task_id: "TASK-3",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      agent_invocation_id: "AINV-3",
+      root_agent_invocation_id: "AINV-3",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-3:2",
+      run_id: "RUN-3",
+      sequence: 2,
+      occurred_at: "2026-08-01T12:10:00.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 20_000_000,
+        cached_input: 19_000_000,
+        output: 400_000,
+        reasoning: 0,
+        total: 20_400_000,
+        source: "provider_reported",
+      },
+      cost: { usd: null, brl: null, fx_rate: null },
+      provider: "openai",
+      model: "gpt-5",
+      source_segment_key: "segment",
+      model_call_id: "MCALL-3",
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-3:3",
+      run_id: "RUN-3",
+      sequence: 3,
+      occurred_at: "2026-08-03T12:00:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: null,
+      duration_provenance: "unavailable",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-3.jsonl"),
+      `${[started, usage, finished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
+    ).toEqual({ duration_ms: null, duration_provenance: null });
+    database.close();
+  });
+  it("unions overlapping source intervals, deduplicates source-segment aliases, and keeps cross-midnight financial facts in their source day", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "07"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    const run = ({
+      id,
+      phase,
+      sourceStartedAt,
+      sourceFinishedAt,
+      parentRunId = null,
+    }: {
+      id: string;
+      phase: "conversation" | "planning" | "execution";
+      sourceStartedAt: string;
+      sourceFinishedAt: string;
+      parentRunId?: string | null;
+    }) => {
+      const occurredAt = sourceStartedAt;
+      const agentInvocationId = `AINV-${id}`;
+      return [
+        {
+          schema_version: 2,
+          event_id: `${id}:1`,
+          run_id: id,
+          sequence: 1,
+          occurred_at: occurredAt,
+          type: "run.started",
+          attribution_status: "attributed",
+          phase,
+          run_role: parentRunId === null ? "orchestrator" : "subagent",
+          run_purpose: "orchestration",
+          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: `thread-${id}`,
+          client_turn_id: `turn-${id}`,
+          conversation_id: `CONV-${id}`,
+          execution_id: `EXEC-${id}`,
+          task_id: `TASK-${id}`,
+          spec_id: null,
+          prd_id: null,
+          change_id: null,
+          parent_run_id: parentRunId,
+          continuation_of_run_id: null,
+          retry_of_run_id: null,
+          agent_invocation_id: agentInvocationId,
+          root_agent_invocation_id: parentRunId === null ? agentInvocationId : "AINV-root",
+          parent_agent_invocation_id: parentRunId === null ? null : "AINV-root",
+          invocation_kind: parentRunId === null ? "orchestrator" : "delegated",
+          delegation_depth: parentRunId === null ? 0 : 1,
+        },
+        {
+          schema_version: 2,
+          event_id: `${id}:2`,
+          run_id: id,
+          sequence: 2,
+          occurred_at: sourceFinishedAt,
+          type: "usage.recorded",
+          phase,
+          activity_kind: "retrospective_local_remeasurement",
+          classification_source: "current_context",
+          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,
+          retrospective_correction: true,
+          source_occurred_at: sourceFinishedAt,
+          source_started_at: sourceStartedAt,
+          source_finished_at: sourceFinishedAt,
+          duration_ms: null,
+          duration_provenance: null,
+        },
+        {
+          schema_version: 2,
+          event_id: `${id}:3`,
+          run_id: id,
+          sequence: 3,
+          occurred_at: new Date(Date.parse(occurredAt) + 60_000).toISOString(),
+          type: "run.finished",
+          phase,
+          status: "completed",
+          duration_ms: 60_000,
+          duration_provenance: "observed",
+        },
+      ];
+    };
+    for (const value of [
+      // 23:17–01:01 São Paulo: factual duration is split at local midnight.
+      {
+        id: "RUN-planning",
+        phase: "planning" as const,
+        sourceStartedAt: "2026-07-23T02:17:00.000Z",
+        sourceFinishedAt: "2026-07-23T04:01:00.000Z",
+      },
+      {
+        id: "RUN-conversation",
+        phase: "conversation" as const,
+        sourceStartedAt: "2026-07-23T03:00:00.000Z",
+        sourceFinishedAt: "2026-07-23T04:01:00.000Z",
+      },
+      {
+        id: "RUN-execution",
+        phase: "execution" as const,
+        sourceStartedAt: "2026-07-23T03:30:00.000Z",
+        sourceFinishedAt: "2026-07-23T04:30:00.000Z",
+      },
+      {
+        id: "RUN-subrun",
+        phase: "execution" as const,
+        parentRunId: "RUN-execution",
+        sourceStartedAt: "2026-07-23T03:45:00.000Z",
+        sourceFinishedAt: "2026-07-23T04:15:00.000Z",
+      },
+    ]) {
+      await writeFile(
+        join(root, ".agents", "records", "runs", "2026", "07", `${value.id}.jsonl`),
+        `${run(value)
+          .map((record) => JSON.stringify(record))
+          .join("\n")}\n`,
+      );
+    }
+    const aliasRecords = run({
+      id: "RUN-source-alias",
+      phase: "execution",
+      sourceStartedAt: "2026-07-23T04:10:00.000Z",
+      sourceFinishedAt: "2026-07-23T04:20:00.000Z",
+    });
+    const aliasUsage = {
+      ...aliasRecords[1],
+      event_id: "RUN-source-alias:3",
+      sequence: 3,
+    };
+    const aliasStarted = {
+      ...aliasRecords[0],
+      // Administrative capture predates the factual source session. Every
+      // token/time/invocation surface must classify this record by the source.
+      occurred_at: "2026-07-22T12:00:00.000Z",
+    };
+    const aliasFinished = { ...aliasRecords[2], event_id: "RUN-source-alias:4", sequence: 4 };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "07", "RUN-source-alias.jsonl"),
+      `${[aliasStarted, aliasRecords[1], aliasUsage, aliasFinished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+    );
+    // Historical financial telemetry can have no agent_invocation_id. It is
+    // still a Cost Monitor financial fact and must not disappear merely
+    // because agent-specific views cannot address it.
+    const historicalRecords = run({
+      id: "RUN-historical-financial",
+      phase: "conversation",
+      sourceStartedAt: "2026-07-23T06:00:00.000Z",
+      sourceFinishedAt: "2026-07-23T06:00:20.000Z",
+    });
+    const historicalStarted = { ...historicalRecords[0] } as Record<string, unknown>;
+    // The record was captured the following day, while its source session is
+    // 23 July. Cost Monitor filters must follow the latter.
+    historicalStarted.occurred_at = "2026-07-24T12:00:00.000Z";
+    delete historicalStarted.agent_invocation_id;
+    delete historicalStarted.root_agent_invocation_id;
+    delete historicalStarted.parent_agent_invocation_id;
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "07", "RUN-historical-financial.jsonl"),
+      `${[historicalStarted, ...historicalRecords.slice(1)].map((record) => JSON.stringify(record)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database
+        .prepare(
+          "SELECT duration_ms, source_duration_ms, duration_provenance FROM zaip_aios_activities WHERE run_id='RUN-planning'",
+        )
+        .get(),
+    ).toEqual({
+      duration_ms: 4_020_000,
+      source_duration_ms: 6_240_000,
+      duration_provenance: "attributed_token_active",
+    });
+    const daily = database
+      .prepare(
+        "SELECT day, total_duration, invocation_count, cost_monitor_invocation_count, cost_monitor_total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day",
+      )
+      .all();
+    expect(daily).toEqual([
+      {
+        day: "2026-07-22",
+        total_duration: 2_580_000,
+        invocation_count: 1,
+        cost_monitor_invocation_count: 1,
+        cost_monitor_total_duration: 2_580_000,
+      },
+      {
+        day: "2026-07-23",
+        total_duration: 5_420_000,
+        invocation_count: 4,
+        cost_monitor_invocation_count: 5,
+        cost_monitor_total_duration: 5_420_000,
+      },
+    ]);
+    expect(
+      database
+        .prepare(
+          "SELECT COUNT(*) AS count FROM zaip_vw_daily_aggregates WHERE total_duration > 86400000",
+        )
+        .get(),
+    ).toEqual({ count: 0 });
+    database.close();
+    const factualFilesystem = new SqliteReadModelFileSystem(root);
+    expect(
+      factualFilesystem
+        .costMonitorFinancialActivityRows({ from: "2026-07-23", to: "2026-07-23" })
+        .some((row) => row.run_id === "RUN-historical-financial"),
+    ).toBe(true);
+    const compactFinancialRow = factualFilesystem.costMonitorFinancialActivityRows({
+      from: "2026-07-23",
+      to: "2026-07-23",
+    })[0];
+    expect(compactFinancialRow).not.toHaveProperty("payload_json");
+    expect(compactFinancialRow).toHaveProperty("total_tokens");
+    expect(
+      factualFilesystem
+        .costMonitorFinancialActivityRows({ from: "2026-07-24", to: "2026-07-24" })
+        .some((row) => row.run_id === "RUN-historical-financial"),
+    ).toBe(false);
+    expect(
+      factualFilesystem
+        .viewPage("operations_agent_invocations", {
+          from: "2026-07-23",
+          to: "2026-07-23",
+          limit: 20,
+        })
+        .rows.some((row) => row.run_id === "RUN-source-alias"),
+    ).toBe(true);
+    expect(
+      factualFilesystem
+        .viewPage("operations_agent_invocations", {
+          from: "2026-07-22",
+          to: "2026-07-22",
+          limit: 20,
+        })
+        .rows.some((row) => row.run_id === "RUN-source-alias"),
+    ).toBe(false);
+    // Filter dimensions stay in the SQL population: they must retain the
+    // source-session day and never require an activity-by-activity lookup.
+    expect(
+      factualFilesystem
+        .costMonitorFinancialActivityRows({
+          from: "2026-07-23",
+          to: "2026-07-23",
+          phases: ["conversation"],
+          providers: ["openai"],
+          models: ["gpt-5"],
+        })
+        .map((row) => row.run_id),
+    ).toContain("RUN-historical-financial");
+    expect(
+      factualFilesystem
+        .costMonitorFinancialActivityRows({
+          from: "2026-07-22",
+          to: "2026-07-22",
+          phases: ["planning"],
+        })
+        .map((row) => row.run_id),
+    ).toEqual(["RUN-planning"]);
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+    ] as const) {
+      expect(
+        factualFilesystem
+          .viewPage(view, { from: "2026-07-23", to: "2026-07-23", limit: 20, offset: 0 })
+          .rows.some((row) => Number(row.total_tokens) === 10),
+      ).toBe(true);
+      // The API boundary supplies inclusive Sao Paulo days as ISO instants.
+      // Do not truncate the UTC end instant into the following calendar day.
+      const bounded = factualFilesystem.viewPage(view, {
+        from: "2026-07-23T03:00:00.000Z",
+        to: "2026-07-24T02:59:59.999Z",
+        limit: 20,
+        offset: 0,
+      }).rows;
+      expect(bounded.some((row) => Number(row.total_tokens) === 10)).toBe(true);
+      expect(
+        bounded.some(
+          (row) =>
+            String(row.period_key).startsWith("2026-07-24") && Number(row.total_tokens) === 10,
+        ),
+      ).toBe(false);
+      // A structural day or other source financial fact may still exist on
+      // the 24th, but this fixture's source-day-23 aggregate must not leak.
+      expect(
+        factualFilesystem
+          .viewPage(view, { from: "2026-07-24", to: "2026-07-24", limit: 20, offset: 0 })
+          .rows.every((row) => row.total_tokens !== 10),
+      ).toBe(true);
+    }
+    const allFinancialRows = factualFilesystem.costMonitorFinancialActivityRows({
+      from: null,
+      to: null,
+    });
+    const factual = factualFilesystem.costMonitorFactualDurationByDay(
+      { from: null, to: null },
+      allFinancialRows,
+    );
+    // The cross-midnight session is split at São Paulo midnight and each day
+    // is the union of complete source intervals, never above one local day.
+    expect(factual.get("2026-07-22")).toEqual({
+      known_sum: 2_580_000,
+      eligible_runs: 1,
+      known_runs: 1,
+    });
+    expect(factual.get("2026-07-23")).toEqual({
+      known_sum: 5_420_000,
+      eligible_runs: 6,
+      known_runs: 6,
+    });
+    factualFilesystem.close();
+  });
+  it("inherits unambiguous SPEC/PRD creation telemetry for planned Tasks without copying it to siblings", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    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-UNIQUE"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-A"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-B"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-PRD-ONLY"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-NO-MACRO"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    const item = (id: string, status = "planned") =>
+      `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}\nrisk: standard\ncreated_at: 2026-08-12T12:00:00.000Z\n---\n# ${id}\n`;
+    for (const id of [
+      "TASK-UNIQUE",
+      "TASK-SHARED-A",
+      "TASK-SHARED-B",
+      "TASK-PRD-ONLY",
+      "TASK-NO-MACRO",
+    ])
+      await writeFile(
+        join(root, ".agents", "records", "tasks", "2026", "08", `${id}.md`),
+        item(id),
+        "utf8",
+      );
+    for (const id of ["SPEC-UNIQUE", "SPEC-SHARED"])
+      await writeFile(
+        join(root, ".agents", "records", "specs", "2026", "08", `${id}.md`),
+        item(id, "active"),
+        "utf8",
+      );
+    for (const id of ["PRD-UNIQUE", "PRD-SHARED", "PRD-ONLY"])
+      await writeFile(
+        join(root, ".agents", "records", "prds", "2026", "08", `${id}.md`),
+        item(id, "active"),
+        "utf8",
+      );
+    const change = (id: string, taskId: string, specId: string | null, prdId: string | null) =>
+      `---\nid: ${id}\ntitle: ${id}\nstatus: planned\nrisk: standard\nsource:\n  type: ${prdId === null ? "task" : "prd"}\n  ${prdId === null ? `task_id: ${taskId}` : `prd_id: ${prdId}`}\n${specId === null ? "" : `  spec_id: ${specId}\n`}task_ids:\n  - ${taskId}\ncreated_at: 2026-08-12T12:00:00.000Z\n---\n# ${id}\n`;
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-UNIQUE", "change.md"),
+      change("CHG-UNIQUE", "TASK-UNIQUE", "SPEC-UNIQUE", "PRD-UNIQUE"),
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-A", "change.md"),
+      change("CHG-SHARED-A", "TASK-SHARED-A", "SPEC-SHARED", "PRD-SHARED"),
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-B", "change.md"),
+      change("CHG-SHARED-B", "TASK-SHARED-B", "SPEC-SHARED", "PRD-SHARED"),
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-PRD-ONLY", "change.md"),
+      change("CHG-PRD-ONLY", "TASK-PRD-ONLY", null, "PRD-ONLY"),
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-NO-MACRO", "change.md"),
+      change("CHG-NO-MACRO", "TASK-NO-MACRO", null, null),
+      "utf8",
+    );
+    const run = (
+      id: string,
+      specId: string | null,
+      prdId: string | null,
+      tokens: number,
+      cost: number,
+      duration: number,
+    ) => [
+      {
+        schema_version: 2,
+        event_id: `${id}:1`,
+        run_id: id,
+        sequence: 1,
+        occurred_at: "2026-08-12T12:00:00.000Z",
+        type: "run.started",
+        attribution_status: "attributed",
+        phase: "planning",
+        run_role: "orchestrator",
+        run_purpose: "orchestration",
+        requires_finalizer: false,
+        execution_kind: "interaction",
+        execution_eligibility: [],
+        entrypoint: specId === null ? (prdId === null ? "conversation" : "prd") : "spec",
+        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: null,
+        task_id: null,
+        spec_id: specId,
+        prd_id: prdId,
+        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: "2026-08-12T12:01:00.000Z",
+        type: "usage.recorded",
+        phase: "planning",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: tokens,
+          cached_input: 0,
+          output: 0,
+          reasoning: 0,
+          total: tokens,
+          source: "provider_reported",
+        },
+        cost: { usd: cost / 5, brl: cost, 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: "2026-08-12T12:02:00.000Z",
+        type: "run.finished",
+        phase: "planning",
+        status: "completed",
+        duration_ms: duration,
+        duration_provenance: "observed",
+      },
+    ];
+    for (const [id, specId, prdId, tokens, cost, duration] of [
+      ["RUN-UNIQUE", "SPEC-UNIQUE", "PRD-UNIQUE", 7, 3, 120_000],
+      ["RUN-SHARED", "SPEC-SHARED", "PRD-SHARED", 11, 5, 60_000],
+      ["RUN-PRD-ONLY", null, "PRD-ONLY", 13, 6, 90_000],
+      ["RUN-NO-MACRO", null, null, 17, 8, 30_000],
+    ] as const)
+      await writeFile(
+        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
+        `${run(id, specId, prdId, tokens, cost, duration)
+          .map((record) => JSON.stringify(record))
+          .join("\n")}\n`,
+        "utf8",
+      );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    const tasks = filesystem.summaryPage("task", { from: null, to: null }, 0, 10).rows;
+    expect(tasks).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-UNIQUE",
+        invocation_count: 1,
+        total_duration: 62_500,
+        total_tokens: 7,
+        total_cost_brl: 3,
+      }),
+    );
+    expect(tasks).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-SHARED-A",
+        invocation_count: null,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      }),
+    );
+    expect(tasks).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-SHARED-B",
+        invocation_count: null,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      }),
+    );
+    expect(tasks).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-PRD-ONLY",
+        invocation_count: 1,
+        total_duration: 32_500,
+        total_tokens: 13,
+        total_cost_brl: 6,
+      }),
+    );
+    expect(tasks).toContainEqual(
+      expect.objectContaining({
+        id: "TASK-NO-MACRO",
+        invocation_count: null,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_brl: null,
+      }),
+    );
+    filesystem.close();
+  });
+});