@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -0,0 +1,2232 @@
+import { mkdir, mkdtemp, readFile, readdir, 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, sourceFingerprint, SqliteReadModelFileSystem } 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 });
+    } 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" }),
+      ]);
+      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.0.8\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();
+  });
+});