@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -0,0 +1,3743 @@
+import { mkdir, mkdtemp, readdir, readFile, rename, utimes, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
+import {
+  allocateAttributedTokenActiveMs,
+  rebuildSqliteReadModel,
+  SqliteReadModelFileSystem,
+  sourceFingerprint,
+} from "./sqlite-read-model.js";
+
+const roots: string[] = [];
+// Windows can deny SQLite's sidecar files below the system TEMP directory.
+// Keep disposable fixtures in the workspace-local test area instead; each
+// test still receives its own root and never touches the live read model.
+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) =>
+        import("node:fs/promises").then(({ rm }) => rm(root, { recursive: true, force: true })),
+      ),
+  );
+});
+
+describe("SQLite dashboard read model", () => {
+  it("snapshots sorted eligible canonical sources once for fingerprinting and ingestion", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const included = join(root, ".agents", "records", "tasks", "nested", "task.md");
+    const excluded = join(root, ".agents", "records", "telemetry", "summary.json");
+    await mkdir(join(root, ".agents", "records", "tasks", "nested"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "telemetry"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await writeFile(included, "# included\n", "utf8");
+    await writeFile(excluded, "ignored\n", "utf8");
+
+    const before = await sourceFingerprint(root);
+    expect(before.candidates.map((candidate) => candidate.source)).toEqual([
+      ".agents/config/project.yaml",
+      ".agents/records/tasks/nested/task.md",
+    ]);
+    expect(before.fingerprint).toContain(".agents/records/tasks/nested/task.md:");
+    const changedAt = new Date(Date.now() + 2_000);
+    await utimes(included, changedAt, changedAt);
+    const after = await sourceFingerprint(root);
+    expect(after.fingerprint).not.toBe(before.fingerprint);
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 2 });
+  });
+
+  it("uses a current-schema seed after a canonical change", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const task = join(root, ".agents", "records", "tasks", "task.md");
+    await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await writeFile(task, "# original\n", "utf8");
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    await writeFile(task, "# changed canonically\n", "utf8");
+    const previousPath = process.env.ZAIP_SQLITE_DB_PATH;
+    const previousSeed = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+    try {
+      process.env.ZAIP_SQLITE_DB_PATH = join(root, ".local", "dashboard-sqlite", "next.sqlite");
+      process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
+      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+        cache: "stale_seed",
+        files: 2,
+      });
+      await expect(rebuildSqliteReadModel(root, { forceCanonical: true })).resolves.toMatchObject({
+        cache: "rebuilt",
+        files: 2,
+      });
+    } finally {
+      if (previousPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+      else process.env.ZAIP_SQLITE_DB_PATH = previousPath;
+      if (previousSeed === undefined) delete process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+      else process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = previousSeed;
+    }
+  });
+
+  it("keeps an exact cached range valid with future facts and fast-paths an empty later month", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    const path = join(root, ".local", "dashboard-sqlite", "read-model.sqlite");
+    const database = new DatabaseSync(path);
+    database
+      .prepare(
+        "UPDATE zaip_aios_activities SET payload_json=? WHERE payload_type='first_fold_monthly_quick_cache'",
+      )
+      .run(
+        JSON.stringify({
+          from_day: "2026-08-01",
+          to_day: "2026-08-18",
+          source_latest_day: "2026-08-30",
+          aggregate: {
+            days: 0,
+            total_run_count: 0,
+            agent_invocation_count: 0,
+            llm_call_count: null,
+            duration_ms: null,
+            total_tokens: null,
+            cost_brl: null,
+            execution_day_count: 0,
+          },
+          pages: { task: [], spec: [], prd: [] },
+          top_tasks: [],
+        }),
+      );
+    database.close();
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2026-08-01", to: "2026-08-18" }),
+      ).not.toBeNull();
+      expect(filesystem.firstFoldMonthlyQuick({ from: "2026-08-01", to: "2026-08-19" })).toBeNull();
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2026-09-01", to: "2026-09-01" }),
+      ).toMatchObject({
+        aggregate: { total_run_count: 0 },
+        pages: { task: [], spec: [], prd: [] },
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("treats an empty snapshot as an exact empty later-month projection", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2099-01-01", to: "2099-01-01" }),
+      ).toMatchObject({
+        aggregate: { total_run_count: 0 },
+        pages: { task: [], spec: [], prd: [] },
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("does not serve a schema 59 seed during the one-time SQLite cache migration", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await writeFile(join(root, ".agents", "records", "tasks", "task.md"), "# task\n", "utf8");
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    const cacheDirectory = join(root, ".local", "dashboard-sqlite", "cache");
+    const current = (await readdir(cacheDirectory)).find(
+      (entry) => entry.startsWith("v60-") && entry.endsWith(".sqlite"),
+    );
+    expect(current).toBeDefined();
+    const legacy = join(cacheDirectory, current!.replace("v60-", ""));
+    await rename(join(cacheDirectory, current!), legacy);
+    const oldSeed = new DatabaseSync(legacy);
+    oldSeed
+      .prepare(
+        "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', '59') WHERE payload_type='metadata' AND json_extract(payload_json, '$.key')='schema_version'",
+      )
+      .run();
+    oldSeed.close();
+    const priorPath = process.env.ZAIP_SQLITE_DB_PATH;
+    const priorSeed = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+    try {
+      process.env.ZAIP_SQLITE_DB_PATH = join(root, ".local", "dashboard-sqlite", "migrated.sqlite");
+      process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
+      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+    } finally {
+      if (priorPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+      else process.env.ZAIP_SQLITE_DB_PATH = priorPath;
+      if (priorSeed === undefined) delete process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+      else process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = priorSeed;
+    }
+  });
+
+  it("rateia sobreposição e virada de dia na fato temporal aditiva", () => {
+    const overlap = allocateAttributedTokenActiveMs([
+      {
+        activityRowId: "A",
+        startMs: Date.parse("2026-08-10T12:00:00.000Z"),
+        endMs: Date.parse("2026-08-10T13:00:00.000Z"),
+      },
+      {
+        activityRowId: "B",
+        startMs: Date.parse("2026-08-10T12:30:00.000Z"),
+        endMs: Date.parse("2026-08-10T13:30:00.000Z"),
+      },
+    ]);
+    expect(overlap.reduce((sum, fact) => sum + fact.value, 0)).toBe(5_400_000);
+    expect(
+      overlap
+        .filter((fact) => fact.activityRowId === "A")
+        .reduce((sum, fact) => sum + fact.value, 0),
+    ).toBe(2_700_000);
+    expect(
+      overlap
+        .filter((fact) => fact.activityRowId === "B")
+        .reduce((sum, fact) => sum + fact.value, 0),
+    ).toBe(2_700_000);
+    const midnight = allocateAttributedTokenActiveMs([
+      {
+        activityRowId: "MID",
+        startMs: Date.parse("2026-08-11T02:30:00.000Z"),
+        endMs: Date.parse("2026-08-11T03:30:00.000Z"),
+      },
+    ]);
+    expect(midnight).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ day: "2026-08-10", value: 1_800_000 }),
+        expect.objectContaining({ day: "2026-08-11", value: 1_800_000 }),
+      ]),
+    );
+  });
+  it("projects canonical executions, conversations, changes and decisions without lifecycle aggregates", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "executions", "2026", "08", "EXEC-1"), {
+      recursive: true,
+    });
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "decisions"), {
+      recursive: true,
+    });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "records", "executions", "2026", "08", "EXEC-1", "execution.md"),
+      `---
+schema_version: 2
+id: EXEC-1
+status: completed
+kind: interaction
+origin:
+  type: interaction
+  conversation_id: CONV-1
+created_at: 2026-08-10T10:00:00.000Z
+finished_at: 2026-08-10T10:05:00.000Z
+---
+
+# Execution
+`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "change.md"),
+      `---
+schema_version: 2
+id: CHG-1
+title: Canonical change
+status: completed
+risk: standard
+source:
+  type: task
+  task_id: TASK-1
+requirement_ids: [REQ-1]
+acceptance_ids: [AC-1]
+task_ids: [TASK-1]
+result: Done
+created_at: 2026-08-10T11:00:00.000Z
+---
+
+# Change
+`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "decisions", "DEC-1.md"),
+      `---
+schema_version: 2
+id: DEC-1
+title: Canonical decision
+origin: agent
+scope_type: change
+scope_id: CHG-1
+created_at: 2026-08-10T11:01:00.000Z
+---
+
+# Decision
+`,
+    );
+
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.viewPage("operations_executions", { limit: 100 })).toMatchObject({
+      total_count: 1,
+      rows: [
+        {
+          execution_id: "EXEC-1",
+          conversation_id: "CONV-1",
+          invocation_count: 0,
+          duration_ms: null,
+          duration_provenance: "unavailable",
+          lifecycle_elapsed_ms: 300_000,
+        },
+      ],
+    });
+    expect(filesystem.viewPage("operations_conversations", { limit: 100 })).toMatchObject({
+      total_count: 1,
+      rows: [{ conversation_id: "CONV-1", invocation_count: 0 }],
+    });
+    expect(filesystem.viewPage("operations_changes", { limit: 100 })).toMatchObject({
+      total_count: 1,
+      rows: [{ id: "CHG-1", title: "Canonical change", source_type: "task" }],
+    });
+    expect(filesystem.viewPage("operations_decisions", { limit: 100 })).toMatchObject({
+      total_count: 1,
+      rows: [{ id: "DEC-1", title: "Canonical decision", scope_id: "CHG-1" }],
+    });
+    // Unfiltered Operations pagination is served from one immutable
+    // generation-local query result, while retaining the public page contract.
+    const workListFirst = filesystem.viewPage("operations_work_list", { limit: 1, offset: 0 });
+    const workListNext = filesystem.viewPage("operations_work_list", { limit: 1, offset: 1 });
+    expect(workListFirst.total_count).toBe(workListNext.total_count);
+    expect(workListFirst.has_more).toBe(workListFirst.total_count > 1);
+    filesystem.close();
+  });
+
+  it("projects catalog personas for canonical, legacy, and host Zaip Agent identities", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(join(root, ".agents", "config", "clients.yaml"), "profiles:\n  - id: codex\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      `agents:
+  - id: agent-orchestrator
+    codex_name: zaip-agent-orchestrator
+    persona: { nome: dave, cargo: product_owner }
+    role: orchestrator
+  - id: agent-builder
+    codex_name: zaip-agent-builder
+    persona: { nome: rafa, cargo: tech_lead }
+    role: builder
+  - id: agent-auditor
+    codex_name: zaip-agent-auditor
+    persona: { nome: ana, cargo: quality_auditor }
+    role: auditor
+  - id: agent-reviewer
+    codex_name: zaip-agent-reviewer
+    persona: { nome: nanda, cargo: principal_engineer }
+    role: reviewer
+  - id: agent-finalizer
+    codex_name: zaip-agent-finalizer
+    compatibility:
+      aliases:
+        - kind: id
+          value: agent-task-finalizer
+        - kind: id
+          value: agent-execution-finalizer
+    persona: { nome: gui, cargo: quality_assurance_lead }
+    role: execution-finalizer
+`,
+    );
+    const expected = new Map([
+      ["agent-builder", ["rafa", "tech_lead"]],
+      ["agent-auditor", ["ana", "quality_auditor"]],
+      ["agent-reviewer", ["nanda", "principal_engineer"]],
+      ["agent-orchestrator", ["dave", "product_owner"]],
+      ["zaip-agent-execution-finalizer", ["gui", "quality_assurance_lead"]],
+      ["zaip-agent-task-finalizer", ["gui", "quality_assurance_lead"]],
+      ["codex", ["codex", "client_host"]],
+    ]);
+    const events = [...expected.keys()].flatMap((agent, index) => {
+      const runId = `RUN-AGENT-${index}`;
+      const started = {
+        schema_version: 2,
+        event_id: `${runId}:1`,
+        run_id: runId,
+        sequence: 1,
+        occurred_at: "2026-08-18T12:00:00.000Z",
+        type: "run.started",
+        attribution_status: "attributed",
+        phase: "execution",
+        run_role: "subagent",
+        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_name: agent,
+        provider: "openai",
+        model: "gpt-5",
+        reasoning_effort: null,
+        client_thread_id: runId,
+        client_turn_id: runId,
+        conversation_id: `CONV-${index}`,
+        execution_id: `EXEC-${index}`,
+        task_id: `TASK-${index}`,
+        spec_id: null,
+        prd_id: null,
+        change_id: null,
+        parent_run_id: "RUN-ROOT",
+        continuation_of_run_id: null,
+        retry_of_run_id: null,
+        agent_invocation_id: `AINV-${index}`,
+        root_agent_invocation_id: "AINV-ROOT",
+        parent_agent_invocation_id: "AINV-ROOT",
+        invocation_kind: "delegated",
+        delegation_depth: 1,
+      };
+      const usage = {
+        schema_version: 2,
+        event_id: `${runId}:2`,
+        run_id: runId,
+        sequence: 2,
+        occurred_at: "2026-08-18T12: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: 0.01, brl: 0.05, fx_rate: 5 },
+        provider: "openai",
+        model: "gpt-5",
+        source_segment_key: runId,
+        model_call_id: `MCALL-${index}`,
+        runtime: { reasoning_effort: null, service_tier: null },
+        supersedes_event_id: null,
+        duration_ms: null,
+        duration_provenance: null,
+      };
+      const finished = {
+        schema_version: 2,
+        event_id: `${runId}:3`,
+        run_id: runId,
+        sequence: 3,
+        occurred_at: "2026-08-18T12:01:00.000Z",
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
+      };
+      return [started, usage, finished];
+    });
+    await Promise.all(
+      [...expected.keys()].map((_, index) =>
+        writeFile(
+          join(root, ".agents", "records", "runs", "2026", "08", `RUN-AGENT-${index}.jsonl`),
+          `${events
+            .slice(index * 3, index * 3 + 3)
+            .map((event) => JSON.stringify(event))
+            .join("\n")}\n`,
+        ),
+      ),
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      const rows = filesystem.viewPage("cost_monitor_zaip_agents", { limit: 20 }).rows;
+      expect(rows).toHaveLength(expected.size);
+      for (const [agent, [persona, job]] of expected) {
+        expect(rows.find((row) => row.key === agent)).toMatchObject({ persona, job });
+      }
+      expect(rows.some((row) => row.persona === null || row.job === null)).toBe(false);
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("marks token and cost telemetry unavailable when a canonical day has only Runs without usage", 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 mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "pricing"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "models.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-08-04T00:00:00.000Z",
+        source: "fixture",
+        disclaimer: "fixture",
+        models: [
+          {
+            id: "gpt-a",
+            provider: "openai",
+            aliases: [],
+            input_per_million_usd: 2,
+            cached_input_per_million_usd: 0.2,
+            output_per_million_usd: 8,
+            reasoning_per_million_usd: 8,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-openai",
+            source_url: "https://example.test/openai",
+            notes: [],
+          },
+          {
+            id: "claude-b",
+            provider: "anthropic",
+            aliases: [],
+            input_per_million_usd: 3,
+            cached_input_per_million_usd: 0.3,
+            output_per_million_usd: 12,
+            reasoning_per_million_usd: null,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-anthropic",
+            source_url: "https://example.test/anthropic",
+            notes: [],
+          },
+        ],
+      }),
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-MISSING:1",
+      run_id: "RUN-MISSING",
+      sequence: 1,
+      occurred_at: "2026-08-05T12:00:00.000Z",
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "conversation",
+      run_role: "orchestrator",
+      run_purpose: "orchestration",
+      requires_finalizer: false,
+      execution_kind: "interaction",
+      execution_eligibility: ["interaction"],
+      entrypoint: "conversation",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "root",
+      agent_name: "root",
+      provider: null,
+      model: "unknown",
+      reasoning_effort: null,
+      client_thread_id: "missing",
+      client_turn_id: "missing",
+      conversation_id: "CONV-MISSING",
+      execution_id: null,
+      task_id: null,
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-MISSING:2",
+      run_id: "RUN-MISSING",
+      sequence: 2,
+      occurred_at: "2026-08-05T12:01:00.000Z",
+      type: "run.finished",
+      phase: "conversation",
+      status: "completed",
+      duration_ms: 60_000,
+      duration_provenance: "observed",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-MISSING.jsonl"),
+      `${JSON.stringify(started)}\n${JSON.stringify(finished)}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.dailyPeriods({ from: null, to: null })["2026-08-05"]).toMatchObject({
+      runs: 1,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: 1 },
+        cost: { known_sum: 0, unknown: 1 },
+      },
+    });
+    filesystem.close();
+  });
+
+  it("releases the real SQLite handle before replacing a generation and reopens it after failure", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    const configPath = join(root, ".agents", "config", "project.yaml");
+    await writeFile(configPath, "zaip:\n  enabled: true\n");
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await filesystem.readText(".agents/config/project.yaml")).toBe(
+        "zaip:\n  enabled: true\n",
+      );
+      expect(filesystem.viewPage("operations_work_list", { limit: 10 }).total_count).toBe(0);
+      const pageCache = (
+        filesystem as unknown as {
+          viewPageResultCache: Map<string, Record<string, unknown>>;
+        }
+      ).viewPageResultCache;
+      expect(pageCache.has('operations_work_list:{"limit":10}')).toBe(true);
+      // Change canonical input only after the read-only database has opened:
+      // rebuild must replace the generation rather than taking the cache path.
+      await writeFile(configPath, "zaip:\n  enabled: true\nproject:\n  id: refreshed-fixture\n");
+      await expect(
+        filesystem.rebuildAndRefresh(() => rebuildSqliteReadModel(root)),
+      ).resolves.toBeUndefined();
+      expect(await filesystem.readText(".agents/config/project.yaml")).toContain(
+        "refreshed-fixture",
+      );
+      expect(pageCache.has('operations_work_list:{"limit":10}')).toBe(false);
+      // Exercise the actual public view on the same reopened instance, not
+      // merely raw filesystem reads after a Windows-safe replacement.
+      expect(() =>
+        filesystem.viewPage("cost_monitor_daily", { limit: 1, offset: 0 }),
+      ).not.toThrow();
+      // A failed rebuild still reopens the existing, complete generation.
+      await expect(
+        filesystem.rebuildAndRefresh(async () => {
+          throw new Error("simulated rebuild failure");
+        }),
+      ).rejects.toThrow("simulated rebuild failure");
+      expect(await filesystem.readText(".agents/config/project.yaml")).toContain(
+        "refreshed-fixture",
+      );
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("keeps Tempo unavailable when token telemetry has no source timing", 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"),
+      "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",
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-1:1",
+      run_id: "RUN-1",
+      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-1",
+      execution_id: "EXEC-1",
+      task_id: "TASK-1",
+      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-1",
+      root_agent_invocation_id: "AINV-1",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-1:2",
+      run_id: "RUN-1",
+      sequence: 2,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 0,
+        cached_input: 0,
+        output: 4_000_000,
+        reasoning: 0,
+        total: 4_000_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-1",
+      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-1:3",
+      run_id: "RUN-1",
+      sequence: 3,
+      occurred_at: "2026-08-01T12: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-1.jsonl"),
+      `${[started, usage, finished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.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();
+    const filesystem = new SqliteReadModelFileSystem(root);
+    const day = filesystem.viewPage("cost_monitor_daily", {
+      from: "2026-08-01",
+      to: "2026-08-01",
+      limit: 20,
+      offset: 0,
+    }).rows[0];
+    if (day === undefined) throw new Error("Expected the daily Cost Monitor row");
+    // Token telemetry without a complete source interval remains unavailable;
+    // a token estimate must never populate the factual Tempo column.
+    expect(day).toMatchObject({
+      total_tokens: 4_000_000,
+      total_duration: null,
+      total_run_count: 1,
+      duration_known: 0,
+      duration_unknown: 1,
+    });
+    expect(Object.keys(day).sort()).toEqual([
+      "duration_known",
+      "duration_unknown",
+      "evidence_count",
+      "key",
+      "label",
+      "prd_count",
+      "spec_count",
+      "task_count",
+      "total_cost_brl",
+      "total_cost_usd",
+      "total_duration",
+      "total_run_count",
+      "total_tokens",
+      "validation_count",
+    ]);
+    expect(
+      filesystem.costMonitorFactualDurationByDay({ from: null, to: null }).get("2026-08-01"),
+    ).toEqual({
+      known_sum: 0,
+      eligible_runs: 1,
+      known_runs: 0,
+    });
+    filesystem.close();
+  });
+
+  it("serves canonical model pricing with recorded-period and current FX", 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", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "pricing", "fx", "2026", "08", "04"), {
+      recursive: true,
+    });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "models.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-08-04T00:00:00.000Z",
+        source: "fixture",
+        disclaimer: "fixture",
+        models: [
+          {
+            id: "gpt-a",
+            provider: "openai",
+            aliases: [],
+            input_per_million_usd: 2,
+            cached_input_per_million_usd: 0.2,
+            output_per_million_usd: 8,
+            reasoning_per_million_usd: 8,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-openai",
+            source_url: "https://example.test/openai",
+            notes: [],
+          },
+        ],
+      }),
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "fx", "2026", "08", "04", "usd-brl.json"),
+      JSON.stringify({
+        schema_version: 1,
+        base: "USD",
+        quote: "BRL",
+        rate: 5.5,
+        as_of: "2026-08-04T00:00:00.000Z",
+        source_label: "fixture",
+        source_url: "https://example.test/fx",
+      }),
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-PRICED:1",
+      run_id: "RUN-PRICED",
+      sequence: 1,
+      occurred_at: "2026-08-08T12: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-a",
+      reasoning_effort: null,
+      client_thread_id: "priced",
+      client_turn_id: "priced",
+      conversation_id: "CONV-PRICED",
+      execution_id: "EXEC-PRICED",
+      task_id: "TASK-PRICED",
+      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-PRICED",
+      root_agent_invocation_id: "AINV-PRICED",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-PRICED:2",
+      run_id: "RUN-PRICED",
+      sequence: 2,
+      occurred_at: "2026-08-08T12:00:01.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 5,
+        cached_input: 0,
+        output: 0,
+        reasoning: 0,
+        total: 5,
+        source: "provider_reported",
+      },
+      cost: { usd: 0.5, brl: 2.5, fx_rate: 5 },
+      provider: "openai",
+      model: "gpt-a",
+      source_segment_key: "openai-gpt-a",
+      model_call_id: "MCALL-PRICED",
+      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-PRICED:3",
+      run_id: "RUN-PRICED",
+      sequence: 3,
+      occurred_at: "2026-08-08T12:01:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: 60_000,
+      duration_provenance: "observed",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-PRICED.jsonl"),
+      `${[started, usage, finished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(filesystem.viewPage("cost_monitor_agent_invocations", {}).rows[0]).toMatchObject({
+        input_rate_usd_per_million: 2,
+        cached_input_rate_usd_per_million: 0.2,
+        output_rate_usd_per_million: 8,
+        calculated_cost_usd: 0.00001,
+        recorded_cost_usd: 0.5,
+        recorded_fx_rate: 5,
+        recorded_brl: 2.5,
+        current_fx_rate: 5.5,
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("keeps orphan telemetry out of the Kanban without dropping its Cost Monitor fact", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks", "2026", "08"), { 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");
+    await writeFile(
+      join(root, ".agents", "records", "tasks", "2026", "08", "TASK-CANONICAL.md"),
+      "---\nid: TASK-CANONICAL\ntitle: Titulo semantico canonico\nstatus: ready\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# Titulo semantico canonico\n",
+    );
+    const run = (id: string, taskId: string, tokens: number) => [
+      {
+        schema_version: 2,
+        event_id: `${id}:1`,
+        run_id: id,
+        sequence: 1,
+        occurred_at: "2026-08-08T12: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-a",
+        reasoning_effort: null,
+        client_thread_id: id,
+        client_turn_id: id,
+        conversation_id: `CONV-${id}`,
+        execution_id: `EXEC-${id}`,
+        task_id: taskId,
+        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-${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-08T12:00:30.000Z",
+        type: "usage.recorded",
+        phase: "execution",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: tokens,
+          cached_input: 0,
+          output: 0,
+          reasoning: 0,
+          total: tokens,
+          source: "provider_reported",
+        },
+        cost: { usd: tokens / 100, brl: tokens / 20, fx_rate: 5 },
+        provider: "openai",
+        model: "gpt-a",
+        source_segment_key: id,
+        model_call_id: `MCALL-${id}`,
+        runtime: { reasoning_effort: null, service_tier: null },
+        supersedes_event_id: null,
+        source_started_at: "2026-08-08T12:00:00.000Z",
+        source_finished_at: "2026-08-08T12:01:00.000Z",
+        duration_ms: null,
+        duration_provenance: null,
+      },
+      {
+        schema_version: 2,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: 3,
+        occurred_at: "2026-08-08T12:01:00.000Z",
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
+      },
+    ];
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL.jsonl"),
+      `${run("RUN-CANONICAL", "TASK-CANONICAL", 7)
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-ORPHAN.jsonl"),
+      `${run("RUN-ORPHAN", "TASK-ORPHAN-REFERENCE", 11)
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+
+    await rebuildSqliteReadModel(root);
+    const snapshot = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      snapshot
+        .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
+        .get(),
+    ).toEqual({ value: "60" });
+    snapshot.close();
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(filesystem.viewPage("operations_work_kanban", { limit: 20 }).rows).toEqual([
+        expect.objectContaining({ id: "TASK-CANONICAL", title: "Titulo semantico canonico" }),
+      ]);
+      // The List export is sourced from this SQLite view, so its known facts
+      // must survive the public entity union rather than be left as blank XLSX
+      // columns by a mapper that only receives identity fields.
+      expect(filesystem.viewPage("operations_work_list", { limit: 20 }).rows).toContainEqual(
+        expect.objectContaining({
+          id: "TASK-CANONICAL",
+          invocation_count: 1,
+          total_duration: 30_000,
+          total_tokens: 7,
+          total_cost_brl: 0.35,
+        }),
+      );
+      const costTasks = filesystem.viewPage("cost_monitor_tasks", { limit: 20 }).rows;
+      expect(costTasks).toContainEqual(
+        expect.objectContaining({
+          id: "TASK-ORPHAN-REFERENCE",
+          total_tokens: 11,
+          total_cost_brl: 0.55,
+        }),
+      );
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  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);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "pricing"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "models.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-08-04T00:00:00.000Z",
+        source: "fixture",
+        disclaimer: "fixture",
+        models: [
+          {
+            id: "gpt-a",
+            provider: "openai",
+            aliases: [],
+            input_per_million_usd: 2,
+            cached_input_per_million_usd: 0.2,
+            output_per_million_usd: 8,
+            reasoning_per_million_usd: 8,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-openai",
+            source_url: "https://example.test/openai",
+            notes: [],
+          },
+          {
+            id: "claude-b",
+            provider: "anthropic",
+            aliases: [],
+            input_per_million_usd: 3,
+            cached_input_per_million_usd: 0.3,
+            output_per_million_usd: 12,
+            reasoning_per_million_usd: null,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-anthropic",
+            source_url: "https://example.test/anthropic",
+            notes: [],
+          },
+        ],
+      }),
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-MULTI:1",
+      run_id: "RUN-MULTI",
+      sequence: 1,
+      occurred_at: "2026-08-04T12: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: "mixed",
+      model: "mixed",
+      reasoning_effort: null,
+      client_thread_id: "multi",
+      client_turn_id: "multi",
+      conversation_id: "CONV-MULTI",
+      execution_id: "EXEC-MULTI",
+      task_id: "TASK-MULTI",
+      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-MULTI",
+      root_agent_invocation_id: "AINV-MULTI",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = (
+      sequence: number,
+      provider: string,
+      model: string,
+      tokens: number,
+      brl: number,
+    ) => ({
+      schema_version: 2,
+      event_id: `RUN-MULTI:${sequence}`,
+      run_id: "RUN-MULTI",
+      sequence,
+      occurred_at: "2026-08-04T12:00:01.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: tokens,
+        cached_input: 0,
+        output: 0,
+        reasoning: 0,
+        total: tokens,
+        source: "provider_reported",
+      },
+      cost: { usd: brl / 5, brl, fx_rate: 5 },
+      provider,
+      model,
+      source_segment_key: `${provider}-${model}`,
+      model_call_id: `MCALL-${sequence}`,
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      source_started_at: "2026-08-04T12:00:00.000Z",
+      source_finished_at: "2026-08-04T12:01:00.000Z",
+      duration_ms: null,
+      duration_provenance: null,
+    });
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-MULTI:5",
+      run_id: "RUN-MULTI",
+      sequence: 5,
+      occurred_at: "2026-08-04T12:01:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: 60_000,
+      duration_provenance: "observed",
+    };
+    const mixedNullSegment = {
+      ...usage(4, "openai", "gpt-a", 0, 0),
+      event_id: "RUN-MULTI:4",
+      provider: null,
+      model: null,
+      source_segment_key: "mixed-null",
+      model_call_id: "MCALL-MIXED-NULL",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-MULTI.jsonl"),
+      `${[started, usage(2, "openai", "gpt-a", 10, 5), usage(3, "anthropic", "claude-b", 20, 10), mixedNullSegment, finished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    const unavailableStarted = {
+      ...started,
+      event_id: "RUN-UNAVAILABLE:1",
+      run_id: "RUN-UNAVAILABLE",
+      occurred_at: "2026-08-04T14:00:00.000Z",
+      client_turn_id: "unavailable",
+      conversation_id: "CONV-UNAVAILABLE",
+      execution_id: "EXEC-UNAVAILABLE",
+      task_id: "TASK-UNAVAILABLE",
+      agent_invocation_id: "AINV-UNAVAILABLE",
+      root_agent_invocation_id: "AINV-UNAVAILABLE",
+      provider: "unavailable",
+      model: "unavailable",
+    };
+    const unavailableFinished = {
+      ...finished,
+      event_id: "RUN-UNAVAILABLE:2",
+      run_id: "RUN-UNAVAILABLE",
+      sequence: 3,
+      occurred_at: "2026-08-04T14:01:00.000Z",
+    };
+    const unavailableUsage = {
+      ...usage(2, "openai", "gpt-a", 0, 0),
+      event_id: "RUN-UNAVAILABLE:usage",
+      run_id: "RUN-UNAVAILABLE",
+      sequence: 2,
+      occurred_at: "2026-08-04T14:00:01.000Z",
+      provider: null,
+      model: null,
+      source_started_at: "2026-08-04T14:00:00.000Z",
+      source_finished_at: "2026-08-04T14:01:00.000Z",
+      source_segment_key: "unknown-segment",
+      model_call_id: "MCALL-UNAVAILABLE",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNAVAILABLE.jsonl"),
+      `${[unavailableStarted, unavailableUsage, unavailableFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    // It is a canonical activity but not an Agent Invocation. Cost Monitor
+    // must not blend this population into its token/cost/session rate.
+    const {
+      agent_invocation_id: _invocation,
+      root_agent_invocation_id: _rootInvocation,
+      parent_agent_invocation_id: _parentInvocation,
+      ...unassistedBase
+    } = started;
+    const unassistedStarted = {
+      ...unassistedBase,
+      event_id: "RUN-UNASSISTED:1",
+      run_id: "RUN-UNASSISTED",
+      occurred_at: "2026-08-04T16:00:00.000Z",
+      client_turn_id: "unassisted",
+      conversation_id: "CONV-UNASSISTED",
+      execution_id: "EXEC-MULTI",
+      task_id: "TASK-MULTI",
+    };
+    const unassistedUsage = {
+      ...usage(2, "openai", "gpt-a", 1_000, 500),
+      event_id: "RUN-UNASSISTED:2",
+      run_id: "RUN-UNASSISTED",
+      occurred_at: "2026-08-04T16:00:01.000Z",
+      source_started_at: "2026-08-04T16:00:00.000Z",
+      source_finished_at: "2026-08-04T16:01:00.000Z",
+      source_segment_key: "unassisted-segment",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNASSISTED.jsonl"),
+      `${[unassistedStarted, unassistedUsage, { ...finished, event_id: "RUN-UNASSISTED:3", run_id: "RUN-UNASSISTED", sequence: 3 }].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    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);
+    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();
+  });
+
+  it("prefers the canonical started-to-finished interval over a token estimate", 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"),
+      "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",
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-2:1",
+      run_id: "RUN-2",
+      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-2",
+      execution_id: "EXEC-2",
+      task_id: "TASK-2",
+      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-2",
+      root_agent_invocation_id: "AINV-2",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-2:2",
+      run_id: "RUN-2",
+      sequence: 2,
+      occurred_at: "2026-08-01T12:10:00.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 4_000_000,
+        cached_input: 0,
+        output: 0,
+        reasoning: 0,
+        total: 4_000_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-2",
+      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-2:3",
+      run_id: "RUN-2",
+      sequence: 3,
+      occurred_at: "2026-08-01T12:30: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-2.jsonl"),
+      `${[started, usage, finished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
+    ).toEqual({ duration_ms: 1_800_000, duration_provenance: "attributed_token_active" });
+    database.close();
+  });
+
+  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/dashboard-sqlite/read-model.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/dashboard-sqlite/read-model.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();
+  });
+
+  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: 1.3.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();
+    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();
+  });
+
+  it("rebuilds a disposable snapshot and serves ZAIP records from SQLite", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(join(root, ".agents", "records", "tasks", "task.md"), "# task\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    const result = await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(result.files).toBe(2);
+    await expect(filesystem.readText(".agents/records/tasks/task.md")).resolves.toContain("task");
+    await expect(filesystem.listFiles(".agents/records", ".md")).resolves.toEqual([
+      ".agents/records/tasks/task.md",
+    ]);
+    filesystem.close();
+  });
+
+  it("serves canonical Task trace inputs without lifecycle manifests", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks", "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",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "tasks", "2026", "08", "TASK-TRACE.md"),
+      "---\nid: TASK-TRACE\ntitle: Canonical trace\nstatus: completed\nrisk: standard\ncreated_at: 2026-08-01T12:00:00.000Z\n---\n# Canonical trace\n",
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.canonicalTraceFiles(["TASK-TRACE"])).toMatchObject([
+      { path: ".agents/records/tasks/2026/08/TASK-TRACE.md" },
+    ]);
+    expect(filesystem.taskTraceUsage("TASK-TRACE")).toEqual({
+      run_count: 0,
+      duration_ms: { value: null, known_runs: 0, unknown_runs: 0, coverage_ratio: 1 },
+      total_tokens: { value: null, known_runs: 0, unknown_runs: 0, coverage_ratio: 1 },
+      cost: {
+        value: null,
+        known_runs: 0,
+        unknown_runs: 0,
+        coverage_ratio: 1,
+        currency: null,
+      },
+    });
+    filesystem.close();
+  });
+
+  it("invalidates a nested canonical source change and ignores legacy aggregate telemetry", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const nested = join(root, ".agents", "records", "tasks", "nested", "task.md");
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "tasks", "nested"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    await writeFile(nested, "# before\n", "utf8");
+    await rebuildSqliteReadModel(root);
+    await writeFile(nested, "# after\n", "utf8");
+    const changedAt = new Date(Date.now() + 2_000);
+    await utimes(nested, changedAt, changedAt);
+    await rebuildSqliteReadModel(root);
+    const updated = new SqliteReadModelFileSystem(root);
+    await expect(updated.readText(".agents/records/tasks/nested/task.md")).resolves.toContain(
+      "after",
+    );
+    updated.close();
+
+    const duplicate = join(
+      root,
+      ".agents",
+      "records",
+      "telemetry",
+      "2026",
+      "08",
+      "writers",
+      "w",
+      "chunks",
+      "c.jsonl",
+    );
+    await mkdir(
+      join(root, ".agents", "records", "telemetry", "2026", "08", "writers", "w", "chunks"),
+      { recursive: true },
+    );
+    await writeFile(
+      join(root, ".agents", "records", "telemetry", "2026", "08", "writers", "w", "manifest.json"),
+      JSON.stringify({
+        chunks: [{ path: ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl" }],
+      }),
+      "utf8",
+    );
+    await writeFile(
+      duplicate,
+      `${JSON.stringify({ agent_invocation_id: "same", summary_hash: "one" })}\n${JSON.stringify({ agent_invocation_id: "same", summary_hash: "two" })}\n`,
+      "utf8",
+    );
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 2 });
+    expect(await readFile(nested, "utf8")).toContain("after");
+    const retained = new SqliteReadModelFileSystem(root);
+    await expect(retained.readText(".agents/records/tasks/nested/task.md")).resolves.toContain(
+      "after",
+    );
+    retained.close();
+  });
+
+  it("does not promote legacy aggregate telemetry into canonical activity facts", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(
+      join(root, ".agents", "records", "telemetry", "2026", "08", "writers", "w", "chunks"),
+      { 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 summary = {
+      agent_invocation_id: "root",
+      summary_hash: "hash",
+      root_agent_invocation_id: "root",
+      parent_agent_invocation_id: null,
+      execution_id: null,
+      task_id: null,
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      run_id: "RUN-1",
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+      source_event_count: 1,
+      historical_cost: {
+        estimated_usd: 2,
+        estimated_brl: 10,
+        fx_rate: 5,
+        pricing_model: "model",
+        pricing_source: "canonical",
+      },
+      quantitative_metrics: { duration_ms: { known_sum: 5 }, tokens_total: { known_sum: 0 } },
+      usage_segments: [
+        {
+          provider: "openai",
+          model: "model",
+          service_tier: "default",
+          reasoning_effort: "medium",
+          tokens: { input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 },
+          historical_cost: {
+            estimated_usd: 2,
+            estimated_brl: 10,
+            fx_rate: 5,
+            pricing_model: "model",
+            pricing_source: "canonical",
+          },
+        },
+      ],
+    };
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "telemetry",
+        "2026",
+        "08",
+        "writers",
+        "w",
+        "chunks",
+        "c.jsonl",
+      ),
+      `${JSON.stringify(summary)}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(root, ".agents", "records", "telemetry", "2026", "08", "writers", "w", "manifest.json"),
+      JSON.stringify({
+        chunks: [{ path: ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl" }],
+      }),
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.firstFoldAggregate({ from: "2026-08-01", to: "2026-08-01" })).toEqual({
+      days: 0,
+      total_run_count: 0,
+      agent_invocation_count: 0,
+      llm_call_count: null,
+      duration_ms: null,
+      total_tokens: null,
+      cost_brl: null,
+      execution_day_count: 0,
+    });
+    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+      readOnly: true,
+    });
+    const columns = (table: string) =>
+      (database.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>).map(
+        (row) => row.name,
+      );
+    expect(columns("zaip_vw_daily_aggregates")).toEqual(
+      expect.arrayContaining([
+        "day",
+        "invocation_count",
+        "total_duration",
+        "total_tokens",
+        "total_cost_usd",
+        "total_cost_brl",
+      ]),
+    );
+    expect(columns("zaip_vw_daily_aggregates")).not.toContain(["sub", "run_count"].join(""));
+    expect(columns("zaip_vw_invocations")).toEqual(
+      expect.arrayContaining([
+        "cost_usd",
+        "cost_brl",
+        "cost_method",
+        "pricing_model",
+        "pricing_source",
+        "fx_rate",
+      ]),
+    );
+    expect(columns("zaip_vw_invocations")).not.toEqual(
+      expect.arrayContaining([
+        "coverage",
+        "_coverage",
+        "usage_segments_json",
+        "estimated_usd",
+        "estimated_brl",
+      ]),
+    );
+    expect(columns("zaip_vw_invocation_usage")).not.toContain("coverage");
+    expect(database.prepare("SELECT COUNT(*) AS count FROM zaip_vw_invocations").get()).toEqual({
+      count: 0,
+    });
+    database.close();
+    filesystem.close();
+  });
+});