@zaip-ai/cli 2.2.0 → 2.6.0

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

@@ -1,17 +1,13 @@
-import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readdir, readFile, rename, rm, utimes, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, rm, utimes, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
-import { expectFastCostPagesMatchCanonical } from "./sqlite-cost-fast-page-parity.test-support.js";
 import {
   allocateAttributedTokenActiveMs,
   rebuildSqliteReadModel,
   SqliteReadModelFileSystem,
   sourceFingerprint,
 } from "./sqlite-read-model.js";
-import { expectPersistedFirstFoldCaches } from "./sqlite-read-model-cache.test-support.js";
 
 const roots: string[] = [];
 const sqliteTestTempRoot = join(
@@ -42,7 +38,6 @@ describe("SQLite dashboard read model", () => {
     await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
   });
-
   it("serves an existing model immediately, refreshes on the SP day boundary and removes deleted sources in place", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -88,7 +83,6 @@ describe("SQLite dashboard read model", () => {
       filesystem.close();
     }
   });
-
   it("rolls back a failed refresh including first-fold payloads while a reader remains open", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -156,7 +150,6 @@ describe("SQLite dashboard read model", () => {
     expect(preservedMetadata.fingerprint).not.toBe(after.fingerprint);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 2 });
   });
-
   it("uses current data entities once when the same ID remains in the legacy layout", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -222,7 +215,6 @@ describe("SQLite dashboard read model", () => {
       fallback.close();
     }
   });
-
   it("accepts only the canonical C3D4 historical assignment among lifecycle files", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -268,7 +260,6 @@ describe("SQLite dashboard read model", () => {
       path: join(root, ".local", "sqlite", "zaip-aios-dashboard.sqlite"),
     });
   });
-
   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);
@@ -322,7 +313,6 @@ describe("SQLite dashboard read model", () => {
       filesystem.close();
     }
   });
-
   it("treats an empty snapshot as an exact empty later-month projection", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -345,7 +335,6 @@ describe("SQLite dashboard read model", () => {
       filesystem.close();
     }
   });
-
   it("uses only the official persistent path after a rebuild", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -372,7 +361,6 @@ describe("SQLite dashboard read model", () => {
       ),
     ).toBe(true);
   });
-
   it("rateia sobreposição e virada de dia na fato temporal aditiva", () => {
     const overlap = allocateAttributedTokenActiveMs([
       {
@@ -511,7 +499,6 @@ created_at: 2026-08-10T11:01:00.000Z
     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);
@@ -667,2795 +654,4 @@ created_at: 2026-08-10T11:01:00.000Z
       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);
-    expectFastCostPagesMatchCanonical(root, filesystem);
-    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/sqlite/zaip-aios-dashboard.sqlite"), {
-      readOnly: true,
-    });
-    expect(
-      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
-    ).toEqual({ duration_ms: null, duration_provenance: null });
-    database.close();
-    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",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-CANONICAL",
-        "artifacts",
-        "tests",
-      ),
-      { recursive: true },
-    );
-    await mkdir(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-CANONICAL",
-        "artifacts",
-        "evidence",
-      ),
-      { 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: completed\ncompleted_run_id: RUN-CANONICAL\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# Titulo semantico canonico\n",
-    );
-    const run = (id: string, taskId: string, tokens: number, changeId: string | null = null) => [
-      {
-        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",
-        developer_identity: {
-          schema_version: 1,
-          provider: "github",
-          account_id: "42",
-          login_snapshot: "dev-fixture",
-          verified_at: "2026-08-08T12:00:00.000Z",
-          attribution_source: "verified_local_account",
-        },
-        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: changeId,
-        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, "CHG-CANONICAL")
-        .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 writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-CANONICAL",
-        "artifacts",
-        "tests",
-        "TEST-CANONICAL.md",
-      ),
-      "---\nid: TEST-CANONICAL\nkind: test\ntask_id: TASK-CANONICAL\nchange_id: CHG-CANONICAL\nrun_id: RUN-CANONICAL\nexecuted_at: 2026-08-08T12:00:00.000Z\nstatus: passed\n---\n# Test\n",
-    );
-    await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-CANONICAL",
-        "artifacts",
-        "evidence",
-        "EVD-CANONICAL.md",
-      ),
-      "---\nid: EVD-CANONICAL\ntask_id: TASK-CANONICAL\nchange_id: CHG-CANONICAL\nrun_id: RUN-CANONICAL\nobserved_at: 2026-08-08T12:00:00.000Z\nstatus: passed\n---\n# Evidence\n",
-    );
-
-    await rebuildSqliteReadModel(root);
-    const snapshot = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
-      readOnly: true,
-    });
-    try {
-      expect(
-        snapshot
-          .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
-          .get(),
-      ).toEqual({ value: "74" });
-    } finally {
-      snapshot.close();
-    }
-    const filesystem = new SqliteReadModelFileSystem(root);
-    try {
-      expect(filesystem.viewPage("operations_work_kanban", { limit: 20 }).rows).toEqual([
-        expect.objectContaining({ id: "TASK-CANONICAL", title: "Titulo semantico canonico" }),
-      ]);
-      // The List export is sourced from this SQLite view, so its known facts
-      // must survive the public entity union rather than be left as blank XLSX
-      // columns by a mapper that only receives identity fields.
-      expect(filesystem.viewPage("operations_work_list", { limit: 20 }).rows).toContainEqual(
-        expect.objectContaining({
-          id: "TASK-CANONICAL",
-          invocation_count: 1,
-          total_duration: 30_000,
-          total_tokens: 7,
-          total_cost_brl: 0.35,
-        }),
-      );
-      const costTasks = filesystem.viewPage("cost_monitor_tasks", { limit: 20 }).rows;
-      expect(costTasks).toContainEqual(
-        expect.objectContaining({
-          id: "TASK-ORPHAN-REFERENCE",
-          total_tokens: 11,
-          total_cost_brl: 0.55,
-        }),
-      );
-      const developers = filesystem.developerCostAggregate({
-        from: null,
-        to: null,
-        accountIds: ["42"],
-      });
-      expect(developers.rows).toEqual([
-        expect.objectContaining({
-          account_id: "42",
-          login_snapshot: "dev-fixture",
-          prd_count: expect.any(Number),
-          spec_count: expect.any(Number),
-          task_count: 2,
-          run_count: 2,
-          test_count: 1,
-          evidence_count: 1,
-          total_duration_ms: expect.any(Number),
-          completed_task_count: 1,
-          total_cost_brl: 0.9,
-          token_covered_runs: 2,
-          usd_covered_runs: 2,
-          brl_covered_runs: 2,
-          qualification: "verified",
-          completed_tasks: [
-            expect.objectContaining({
-              id: "TASK-CANONICAL",
-              status: "completed",
-              completed_run_id: "RUN-CANONICAL",
-              delivered_by: { account_id: "42" },
-              contributors: [expect.objectContaining({ account_id: "42" })],
-            }),
-          ],
-        }),
-      ]);
-      expect(
-        filesystem.developerCostAggregate({
-          from: "2026-08-08",
-          to: "2026-08-08",
-          accountIds: ["42"],
-        }).rows,
-      ).toEqual([expect.objectContaining({ test_count: 1, evidence_count: 1 })]);
-      expect(
-        filesystem.dailyPeriods({ from: "2026-08-08", to: "2026-08-08" })["2026-08-08"],
-      ).toMatchObject({ validations: 1, evidences: 1 });
-      const operationsDevelopers = filesystem.operationsDeveloperAggregate({
-        from: null,
-        to: null,
-        accountIds: ["42"],
-      });
-      expect(operationsDevelopers.rows).toEqual([
-        expect.objectContaining({
-          account_id: "42",
-          task_count: 2,
-          completed_task_count: 1,
-          status_counts: expect.objectContaining({ completed: 1 }),
-          type_counts: { task: 1 },
-          risk_counts: expect.any(Object),
-          total_duration_ms: expect.any(Number),
-          total_tokens: expect.any(Number),
-          total_cost_brl: 0.9,
-        }),
-      ]);
-    } finally {
-      filesystem.close();
-    }
-  });
-
-  it("qualifies factual developer deliveries without inventing missing completion or coverage", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    const runsRoot = join(root, ".agents", "records", "runs", "2026", "08");
-    const tasksRoot = join(root, ".agents", "records", "tasks", "2026", "08");
-    const assignmentsRoot = join(
-      root,
-      ".agents",
-      "records",
-      "lifecycle",
-      "historical-developer-attribution",
-    );
-    await Promise.all([
-      mkdir(runsRoot, { recursive: true }),
-      mkdir(tasksRoot, { recursive: true }),
-      mkdir(assignmentsRoot, { recursive: true }),
-      mkdir(join(root, ".agents", "config"), { recursive: true }),
-    ]);
-    await writeFile(
-      join(root, ".agents", "config", "project.yaml"),
-      "zaip:\n  enabled: true\n",
-      "utf8",
-    );
-    const task = (id: string, status: string, completedRunId: string | null) =>
-      `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}${completedRunId === null ? "" : `\ncompleted_run_id: ${completedRunId}`}\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# ${id}\n`;
-    await Promise.all([
-      writeFile(
-        join(tasksRoot, "TASK-DELIVERED.md"),
-        task("TASK-DELIVERED", "completed", "RUN-DELIVERED"),
-      ),
-      writeFile(
-        join(tasksRoot, "TASK-NO-COMPLETION.md"),
-        task("TASK-NO-COMPLETION", "completed", null),
-      ),
-      writeFile(
-        join(tasksRoot, "TASK-MISSING-RUN.md"),
-        task("TASK-MISSING-RUN", "completed", "RUN-NOT-FOUND"),
-      ),
-      writeFile(
-        join(tasksRoot, "TASK-NOT-COMPLETED.md"),
-        task("TASK-NOT-COMPLETED", "executing", "RUN-NOT-COMPLETED"),
-      ),
-      writeFile(
-        join(tasksRoot, "TASK-UNKNOWN-COVERAGE.md"),
-        task("TASK-UNKNOWN-COVERAGE", "completed", null),
-      ),
-      writeFile(
-        join(tasksRoot, "TASK-HISTORICAL.md"),
-        task("TASK-HISTORICAL", "completed", "RUN-HISTORICAL"),
-      ),
-    ]);
-    const stream = (
-      id: string,
-      taskId: string,
-      accountId: string | null,
-      day: string,
-      tokens: number | null,
-    ) => {
-      const identity =
-        accountId === null
-          ? null
-          : {
-              schema_version: 1,
-              provider: "github",
-              account_id: accountId,
-              login_snapshot: `dev-${accountId}`,
-              verified_at: `${day}T12:00:00.000Z`,
-              attribution_source: "verified_local_account",
-            };
-      const records: Record<string, unknown>[] = [
-        {
-          schema_version: 2,
-          event_id: `${id}:1`,
-          run_id: id,
-          sequence: 1,
-          occurred_at: `${day}T12: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",
-          developer_identity: identity,
-          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,
-        },
-      ];
-      if (tokens !== null)
-        records.push({
-          schema_version: 2,
-          event_id: `${id}:2`,
-          run_id: id,
-          sequence: 2,
-          occurred_at: `${day}T12: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: `${day}T12:00:00.000Z`,
-          source_finished_at: `${day}T12:01:00.000Z`,
-          duration_ms: null,
-          duration_provenance: null,
-        });
-      records.push({
-        schema_version: 2,
-        event_id: `${id}:3`,
-        run_id: id,
-        sequence: records.length + 1,
-        occurred_at: `${day}T12:01:00.000Z`,
-        type: "run.finished",
-        phase: "execution",
-        status: "completed",
-        duration_ms: 60_000,
-        duration_provenance: "observed",
-      });
-      return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`;
-    };
-    const delivered = stream("RUN-DELIVERED", "TASK-DELIVERED", "42", "2026-08-08", 10);
-    const contributor = stream("RUN-CONTRIBUTOR", "TASK-DELIVERED", "99", "2026-08-08", 3);
-    const noCompletion = stream("RUN-NO-COMPLETION", "TASK-NO-COMPLETION", "42", "2026-08-09", 4);
-    const notCompleted = stream("RUN-NOT-COMPLETED", "TASK-NOT-COMPLETED", "42", "2026-08-09", 5);
-    const unknownCoverage = stream(
-      "RUN-UNKNOWN-COVERAGE",
-      "TASK-UNKNOWN-COVERAGE",
-      "42",
-      "2026-08-09",
-      null,
-    );
-    const historical = stream("RUN-HISTORICAL", "TASK-HISTORICAL", null, "2026-08-09", 2);
-    await Promise.all([
-      writeFile(join(runsRoot, "RUN-DELIVERED.jsonl"), delivered),
-      writeFile(join(runsRoot, "RUN-CONTRIBUTOR.jsonl"), contributor),
-      writeFile(join(runsRoot, "RUN-NO-COMPLETION.jsonl"), noCompletion),
-      writeFile(join(runsRoot, "RUN-NOT-COMPLETED.jsonl"), notCompleted),
-      writeFile(join(runsRoot, "RUN-UNKNOWN-COVERAGE.jsonl"), unknownCoverage),
-      writeFile(join(runsRoot, "RUN-HISTORICAL.jsonl"), historical),
-    ]);
-    const historicalPath = ".agents/records/runs/2026/08/RUN-HISTORICAL.jsonl";
-    const unsigned = {
-      schema_version: 1,
-      manifest_id: "HDA-FIXTURE",
-      created_at: "2026-08-09T12:00:00.000Z",
-      kind: "historical_developer_attribution",
-      assignment: {
-        schema_version: 1,
-        provider: "github",
-        account_id: "199126185",
-        login_snapshot: "zaip-ai",
-        attribution_source: "human_assigned",
-        verified_at: null,
-      },
-      source_streams: [
-        {
-          run_id: "RUN-HISTORICAL",
-          path: historicalPath,
-          content_sha256: createHash("sha256").update(historical).digest("hex"),
-        },
-      ],
-    };
-    await writeFile(
-      join(assignmentsRoot, "HDA-FIXTURE.json"),
-      JSON.stringify({
-        ...unsigned,
-        manifest_hash: createHash("sha256").update(JSON.stringify(unsigned)).digest("hex"),
-      }),
-    );
-    await rebuildSqliteReadModel(root);
-    const filesystem = new SqliteReadModelFileSystem(root);
-    try {
-      const all = filesystem.developerCostAggregate({ from: null, to: null });
-      const deliveredBy42 = all.rows.find((row) => row.account_id === "42")!;
-      expect(deliveredBy42).toMatchObject({
-        qualification: "verified",
-        completed_task_count: 1,
-        run_count: 4,
-        token_covered_runs: 3,
-        usd_covered_runs: 3,
-        brl_covered_runs: 3,
-      });
-      expect(deliveredBy42.completed_tasks).toEqual([
-        expect.objectContaining({
-          id: "TASK-DELIVERED",
-          completed_run_id: "RUN-DELIVERED",
-          delivered_by: { account_id: "42" },
-          contributors: expect.arrayContaining([
-            expect.objectContaining({ account_id: "42" }),
-            expect.objectContaining({ account_id: "99" }),
-          ]),
-        }),
-      ]);
-      // Operations counts completed Tasks from the same canonical Task facts
-      // as its status distribution; no completed_run_id is required there.
-      expect(
-        filesystem
-          .operationsDeveloperAggregate({ from: null, to: null })
-          .rows.find((row) => row.account_id === "42"),
-      ).toMatchObject({
-        completed_task_count: 3,
-        status_counts: expect.objectContaining({ completed: 3 }),
-      });
-      expect(all.rows.find((row) => row.account_id === "199126185")).toMatchObject({
-        qualification: "human_assigned",
-        completed_task_count: 1,
-      });
-      expect(
-        filesystem.developerCostAggregate({
-          from: "2026-08-08",
-          to: "2026-08-08",
-          accountIds: ["42"],
-        }).rows,
-      ).toHaveLength(1);
-      expect(
-        filesystem.developerCostAggregate({
-          from: "2026-08-09",
-          to: "2026-08-09",
-          accountIds: ["42"],
-        }).rows[0],
-      ).toMatchObject({ completed_task_count: 0 });
-      // The real attributed unknown Run remains linked to account 42. Its
-      // coverage gap is explicit; its absent measures are never a zero.
-      const unknownDay = filesystem.developerCostAggregate({
-        from: "2026-08-09",
-        to: "2026-08-09",
-        accountIds: ["42"],
-      }).rows[0]!;
-      expect(unknownDay).toMatchObject({
-        run_count: 3,
-        token_covered_runs: 2,
-        usd_covered_runs: 2,
-        brl_covered_runs: 2,
-      });
-      expect(unknownDay.total_tokens).toBe(9);
-      expect(
-        filesystem.dailyPeriods({ from: "2026-08-09", to: "2026-08-09" })["2026-08-09"],
-      ).toMatchObject({
-        runs: 4,
-        usage: {
-          total_tokens: { known_sum: 11, unknown: 1 },
-          cost: { known_sum: 0.55, unknown: 1 },
-        },
-      });
-    } finally {
-      filesystem.close();
-    }
-    await writeFile(join(assignmentsRoot, "HDA-FIXTURE.json"), "{corrupt");
-    await rebuildSqliteReadModel(root, { forceCanonical: true });
-    const corrupt = new SqliteReadModelFileSystem(root);
-    try {
-      expect(
-        corrupt.developerCostAggregate({ from: null, to: null }).rows.map((row) => row.account_id),
-      ).not.toContain("199126185");
-    } finally {
-      corrupt.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/sqlite/zaip-aios-dashboard.sqlite"), {
-      readOnly: true,
-    });
-    expect(
-      database
-        .prepare(
-          "SELECT duration_ms, duration_provenance FROM zaip_aios_activities WHERE payload_type IS NULL",
-        )
-        .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/sqlite/zaip-aios-dashboard.sqlite"), {
-      readOnly: true,
-    });
-    expect(
-      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
-    ).toEqual({ duration_ms: null, duration_provenance: null });
-    database.close();
-  });
-
-  it("unions overlapping source intervals, deduplicates source-segment aliases, and keeps cross-midnight financial facts in their source day", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    await mkdir(join(root, ".agents", "records", "runs", "2026", "07"), { recursive: true });
-    await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
-    const run = ({
-      id,
-      phase,
-      sourceStartedAt,
-      sourceFinishedAt,
-      parentRunId = null,
-    }: {
-      id: string;
-      phase: "conversation" | "planning" | "execution";
-      sourceStartedAt: string;
-      sourceFinishedAt: string;
-      parentRunId?: string | null;
-    }) => {
-      const occurredAt = sourceStartedAt;
-      const agentInvocationId = `AINV-${id}`;
-      return [
-        {
-          schema_version: 2,
-          event_id: `${id}:1`,
-          run_id: id,
-          sequence: 1,
-          occurred_at: occurredAt,
-          type: "run.started",
-          attribution_status: "attributed",
-          phase,
-          run_role: parentRunId === null ? "orchestrator" : "subagent",
-          run_purpose: "orchestration",
-          requires_finalizer: false,
-          execution_kind: "delivery",
-          execution_eligibility: ["delivery"],
-          entrypoint: "task",
-          work_type: "new",
-          storage_mode: "tracked_sanitized",
-          client: "codex",
-          agent: "agent",
-          agent_name: "agent",
-          provider: "openai",
-          model: "gpt-5",
-          reasoning_effort: null,
-          client_thread_id: `thread-${id}`,
-          client_turn_id: `turn-${id}`,
-          conversation_id: `CONV-${id}`,
-          execution_id: `EXEC-${id}`,
-          task_id: `TASK-${id}`,
-          spec_id: null,
-          prd_id: null,
-          change_id: null,
-          parent_run_id: parentRunId,
-          continuation_of_run_id: null,
-          retry_of_run_id: null,
-          agent_invocation_id: agentInvocationId,
-          root_agent_invocation_id: parentRunId === null ? agentInvocationId : "AINV-root",
-          parent_agent_invocation_id: parentRunId === null ? null : "AINV-root",
-          invocation_kind: parentRunId === null ? "orchestrator" : "delegated",
-          delegation_depth: parentRunId === null ? 0 : 1,
-        },
-        {
-          schema_version: 2,
-          event_id: `${id}:2`,
-          run_id: id,
-          sequence: 2,
-          occurred_at: sourceFinishedAt,
-          type: "usage.recorded",
-          phase,
-          activity_kind: "retrospective_local_remeasurement",
-          classification_source: "current_context",
-          tokens: {
-            input: 1,
-            cached_input: 0,
-            output: 1,
-            reasoning: 0,
-            total: 2,
-            source: "provider_reported",
-          },
-          cost: { usd: 1, brl: 5, fx_rate: 5 },
-          provider: "openai",
-          model: "gpt-5",
-          source_segment_key: id,
-          model_call_id: `MCALL-${id}`,
-          runtime: { reasoning_effort: null, service_tier: null },
-          supersedes_event_id: null,
-          retrospective_correction: true,
-          source_occurred_at: sourceFinishedAt,
-          source_started_at: sourceStartedAt,
-          source_finished_at: sourceFinishedAt,
-          duration_ms: null,
-          duration_provenance: null,
-        },
-        {
-          schema_version: 2,
-          event_id: `${id}:3`,
-          run_id: id,
-          sequence: 3,
-          occurred_at: new Date(Date.parse(occurredAt) + 60_000).toISOString(),
-          type: "run.finished",
-          phase,
-          status: "completed",
-          duration_ms: 60_000,
-          duration_provenance: "observed",
-        },
-      ];
-    };
-    for (const value of [
-      // 23:17–01:01 São Paulo: factual duration is split at local midnight.
-      {
-        id: "RUN-planning",
-        phase: "planning" as const,
-        sourceStartedAt: "2026-07-23T02:17:00.000Z",
-        sourceFinishedAt: "2026-07-23T04:01:00.000Z",
-      },
-      {
-        id: "RUN-conversation",
-        phase: "conversation" as const,
-        sourceStartedAt: "2026-07-23T03:00:00.000Z",
-        sourceFinishedAt: "2026-07-23T04:01:00.000Z",
-      },
-      {
-        id: "RUN-execution",
-        phase: "execution" as const,
-        sourceStartedAt: "2026-07-23T03:30:00.000Z",
-        sourceFinishedAt: "2026-07-23T04:30:00.000Z",
-      },
-      {
-        id: "RUN-subrun",
-        phase: "execution" as const,
-        parentRunId: "RUN-execution",
-        sourceStartedAt: "2026-07-23T03:45:00.000Z",
-        sourceFinishedAt: "2026-07-23T04:15:00.000Z",
-      },
-    ]) {
-      await writeFile(
-        join(root, ".agents", "records", "runs", "2026", "07", `${value.id}.jsonl`),
-        `${run(value)
-          .map((record) => JSON.stringify(record))
-          .join("\n")}\n`,
-      );
-    }
-    const aliasRecords = run({
-      id: "RUN-source-alias",
-      phase: "execution",
-      sourceStartedAt: "2026-07-23T04:10:00.000Z",
-      sourceFinishedAt: "2026-07-23T04:20:00.000Z",
-    });
-    const aliasUsage = {
-      ...aliasRecords[1],
-      event_id: "RUN-source-alias:3",
-      sequence: 3,
-    };
-    const aliasStarted = {
-      ...aliasRecords[0],
-      // Administrative capture predates the factual source session. Every
-      // token/time/invocation surface must classify this record by the source.
-      occurred_at: "2026-07-22T12:00:00.000Z",
-    };
-    const aliasFinished = { ...aliasRecords[2], event_id: "RUN-source-alias:4", sequence: 4 };
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "07", "RUN-source-alias.jsonl"),
-      `${[aliasStarted, aliasRecords[1], aliasUsage, aliasFinished].map((record) => JSON.stringify(record)).join("\n")}\n`,
-    );
-    // Historical financial telemetry can have no agent_invocation_id. It is
-    // still a Cost Monitor financial fact and must not disappear merely
-    // because agent-specific views cannot address it.
-    const historicalRecords = run({
-      id: "RUN-historical-financial",
-      phase: "conversation",
-      sourceStartedAt: "2026-07-23T06:00:00.000Z",
-      sourceFinishedAt: "2026-07-23T06:00:20.000Z",
-    });
-    const historicalStarted = { ...historicalRecords[0] } as Record<string, unknown>;
-    // The record was captured the following day, while its source session is
-    // 23 July. Cost Monitor filters must follow the latter.
-    historicalStarted.occurred_at = "2026-07-24T12:00:00.000Z";
-    delete historicalStarted.agent_invocation_id;
-    delete historicalStarted.root_agent_invocation_id;
-    delete historicalStarted.parent_agent_invocation_id;
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "07", "RUN-historical-financial.jsonl"),
-      `${[historicalStarted, ...historicalRecords.slice(1)].map((record) => JSON.stringify(record)).join("\n")}\n`,
-    );
-    await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
-      readOnly: true,
-    });
-    expect(
-      database
-        .prepare(
-          "SELECT duration_ms, source_duration_ms, duration_provenance FROM zaip_aios_activities WHERE run_id='RUN-planning'",
-        )
-        .get(),
-    ).toEqual({
-      duration_ms: 4_020_000,
-      source_duration_ms: 6_240_000,
-      duration_provenance: "attributed_token_active",
-    });
-    const daily = database
-      .prepare(
-        "SELECT day, total_duration, invocation_count, cost_monitor_invocation_count, cost_monitor_total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day",
-      )
-      .all();
-    expect(daily).toEqual([
-      {
-        day: "2026-07-22",
-        total_duration: 2_580_000,
-        invocation_count: 1,
-        cost_monitor_invocation_count: 1,
-        cost_monitor_total_duration: 2_580_000,
-      },
-      {
-        day: "2026-07-23",
-        total_duration: 5_420_000,
-        invocation_count: 4,
-        cost_monitor_invocation_count: 5,
-        cost_monitor_total_duration: 5_420_000,
-      },
-    ]);
-    expect(
-      database
-        .prepare(
-          "SELECT COUNT(*) AS count FROM zaip_vw_daily_aggregates WHERE total_duration > 86400000",
-        )
-        .get(),
-    ).toEqual({ count: 0 });
-    database.close();
-    const factualFilesystem = new SqliteReadModelFileSystem(root);
-    expect(
-      factualFilesystem
-        .costMonitorFinancialActivityRows({ from: "2026-07-23", to: "2026-07-23" })
-        .some((row) => row.run_id === "RUN-historical-financial"),
-    ).toBe(true);
-    const compactFinancialRow = factualFilesystem.costMonitorFinancialActivityRows({
-      from: "2026-07-23",
-      to: "2026-07-23",
-    })[0];
-    expect(compactFinancialRow).not.toHaveProperty("payload_json");
-    expect(compactFinancialRow).toHaveProperty("total_tokens");
-    expect(
-      factualFilesystem
-        .costMonitorFinancialActivityRows({ from: "2026-07-24", to: "2026-07-24" })
-        .some((row) => row.run_id === "RUN-historical-financial"),
-    ).toBe(false);
-    expect(
-      factualFilesystem
-        .viewPage("operations_agent_invocations", {
-          from: "2026-07-23",
-          to: "2026-07-23",
-          limit: 20,
-        })
-        .rows.some((row) => row.run_id === "RUN-source-alias"),
-    ).toBe(true);
-    expect(
-      factualFilesystem
-        .viewPage("operations_agent_invocations", {
-          from: "2026-07-22",
-          to: "2026-07-22",
-          limit: 20,
-        })
-        .rows.some((row) => row.run_id === "RUN-source-alias"),
-    ).toBe(false);
-    // Filter dimensions stay in the SQL population: they must retain the
-    // source-session day and never require an activity-by-activity lookup.
-    expect(
-      factualFilesystem
-        .costMonitorFinancialActivityRows({
-          from: "2026-07-23",
-          to: "2026-07-23",
-          phases: ["conversation"],
-          providers: ["openai"],
-          models: ["gpt-5"],
-        })
-        .map((row) => row.run_id),
-    ).toContain("RUN-historical-financial");
-    expect(
-      factualFilesystem
-        .costMonitorFinancialActivityRows({
-          from: "2026-07-22",
-          to: "2026-07-22",
-          phases: ["planning"],
-        })
-        .map((row) => row.run_id),
-    ).toEqual(["RUN-planning"]);
-    for (const view of [
-      "cost_monitor_daily",
-      "cost_monitor_monthly",
-      "cost_monitor_annual",
-    ] as const) {
-      expect(
-        factualFilesystem
-          .viewPage(view, { from: "2026-07-23", to: "2026-07-23", limit: 20, offset: 0 })
-          .rows.some((row) => Number(row.total_tokens) === 10),
-      ).toBe(true);
-      // The API boundary supplies inclusive Sao Paulo days as ISO instants.
-      // Do not truncate the UTC end instant into the following calendar day.
-      const bounded = factualFilesystem.viewPage(view, {
-        from: "2026-07-23T03:00:00.000Z",
-        to: "2026-07-24T02:59:59.999Z",
-        limit: 20,
-        offset: 0,
-      }).rows;
-      expect(bounded.some((row) => Number(row.total_tokens) === 10)).toBe(true);
-      expect(
-        bounded.some(
-          (row) =>
-            String(row.period_key).startsWith("2026-07-24") && Number(row.total_tokens) === 10,
-        ),
-      ).toBe(false);
-      // A structural day or other source financial fact may still exist on
-      // the 24th, but this fixture's source-day-23 aggregate must not leak.
-      expect(
-        factualFilesystem
-          .viewPage(view, { from: "2026-07-24", to: "2026-07-24", limit: 20, offset: 0 })
-          .rows.every((row) => row.total_tokens !== 10),
-      ).toBe(true);
-    }
-    const allFinancialRows = factualFilesystem.costMonitorFinancialActivityRows({
-      from: null,
-      to: null,
-    });
-    const factual = factualFilesystem.costMonitorFactualDurationByDay(
-      { from: null, to: null },
-      allFinancialRows,
-    );
-    // The cross-midnight session is split at São Paulo midnight and each day
-    // is the union of complete source intervals, never above one local day.
-    expect(factual.get("2026-07-22")).toEqual({
-      known_sum: 2_580_000,
-      eligible_runs: 1,
-      known_runs: 1,
-    });
-    expect(factual.get("2026-07-23")).toEqual({
-      known_sum: 5_420_000,
-      eligible_runs: 6,
-      known_runs: 6,
-    });
-    factualFilesystem.close();
-  });
-
-  it("inherits unambiguous SPEC/PRD creation telemetry for planned Tasks without copying it to siblings", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    for (const kind of ["tasks", "specs", "prds"])
-      await mkdir(join(root, ".agents", "records", kind, "2026", "08"), { recursive: true });
-    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-UNIQUE"), {
-      recursive: true,
-    });
-    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-A"), {
-      recursive: true,
-    });
-    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-B"), {
-      recursive: true,
-    });
-    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-PRD-ONLY"), {
-      recursive: true,
-    });
-    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-NO-MACRO"), {
-      recursive: true,
-    });
-    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
-    await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(
-      join(root, ".agents", "config", "project.yaml"),
-      "zaip:\n  enabled: true\n",
-      "utf8",
-    );
-    const item = (id: string, status = "planned") =>
-      `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}\nrisk: standard\ncreated_at: 2026-08-12T12:00:00.000Z\n---\n# ${id}\n`;
-    for (const id of [
-      "TASK-UNIQUE",
-      "TASK-SHARED-A",
-      "TASK-SHARED-B",
-      "TASK-PRD-ONLY",
-      "TASK-NO-MACRO",
-    ])
-      await writeFile(
-        join(root, ".agents", "records", "tasks", "2026", "08", `${id}.md`),
-        item(id),
-        "utf8",
-      );
-    for (const id of ["SPEC-UNIQUE", "SPEC-SHARED"])
-      await writeFile(
-        join(root, ".agents", "records", "specs", "2026", "08", `${id}.md`),
-        item(id, "active"),
-        "utf8",
-      );
-    for (const id of ["PRD-UNIQUE", "PRD-SHARED", "PRD-ONLY"])
-      await writeFile(
-        join(root, ".agents", "records", "prds", "2026", "08", `${id}.md`),
-        item(id, "active"),
-        "utf8",
-      );
-    const change = (id: string, taskId: string, specId: string | null, prdId: string | null) =>
-      `---\nid: ${id}\ntitle: ${id}\nstatus: planned\nrisk: standard\nsource:\n  type: ${prdId === null ? "task" : "prd"}\n  ${prdId === null ? `task_id: ${taskId}` : `prd_id: ${prdId}`}\n${specId === null ? "" : `  spec_id: ${specId}\n`}task_ids:\n  - ${taskId}\ncreated_at: 2026-08-12T12:00:00.000Z\n---\n# ${id}\n`;
-    await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-UNIQUE", "change.md"),
-      change("CHG-UNIQUE", "TASK-UNIQUE", "SPEC-UNIQUE", "PRD-UNIQUE"),
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-A", "change.md"),
-      change("CHG-SHARED-A", "TASK-SHARED-A", "SPEC-SHARED", "PRD-SHARED"),
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-SHARED-B", "change.md"),
-      change("CHG-SHARED-B", "TASK-SHARED-B", "SPEC-SHARED", "PRD-SHARED"),
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-PRD-ONLY", "change.md"),
-      change("CHG-PRD-ONLY", "TASK-PRD-ONLY", null, "PRD-ONLY"),
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-NO-MACRO", "change.md"),
-      change("CHG-NO-MACRO", "TASK-NO-MACRO", null, null),
-      "utf8",
-    );
-    const run = (
-      id: string,
-      specId: string | null,
-      prdId: string | null,
-      tokens: number,
-      cost: number,
-      duration: number,
-    ) => [
-      {
-        schema_version: 2,
-        event_id: `${id}:1`,
-        run_id: id,
-        sequence: 1,
-        occurred_at: "2026-08-12T12:00:00.000Z",
-        type: "run.started",
-        attribution_status: "attributed",
-        phase: "planning",
-        run_role: "orchestrator",
-        run_purpose: "orchestration",
-        requires_finalizer: false,
-        execution_kind: "interaction",
-        execution_eligibility: [],
-        entrypoint: specId === null ? (prdId === null ? "conversation" : "prd") : "spec",
-        work_type: "new",
-        storage_mode: "tracked_sanitized",
-        client: "codex",
-        agent: "agent",
-        agent_name: "agent",
-        provider: "openai",
-        model: "gpt-5",
-        reasoning_effort: null,
-        client_thread_id: id,
-        client_turn_id: id,
-        conversation_id: `CONV-${id}`,
-        execution_id: null,
-        task_id: null,
-        spec_id: specId,
-        prd_id: prdId,
-        change_id: null,
-        parent_run_id: null,
-        continuation_of_run_id: null,
-        retry_of_run_id: null,
-        agent_invocation_id: `AINV-${id}`,
-        root_agent_invocation_id: `AINV-${id}`,
-        parent_agent_invocation_id: null,
-        invocation_kind: "orchestrator",
-        delegation_depth: 0,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:2`,
-        run_id: id,
-        sequence: 2,
-        occurred_at: "2026-08-12T12:01:00.000Z",
-        type: "usage.recorded",
-        phase: "planning",
-        activity_kind: "model_usage",
-        classification_source: "explicit",
-        tokens: {
-          input: tokens,
-          cached_input: 0,
-          output: 0,
-          reasoning: 0,
-          total: tokens,
-          source: "provider_reported",
-        },
-        cost: { usd: cost / 5, brl: cost, fx_rate: 5 },
-        provider: "openai",
-        model: "gpt-5",
-        source_segment_key: id,
-        model_call_id: `MCALL-${id}`,
-        runtime: { reasoning_effort: null, service_tier: null },
-        supersedes_event_id: null,
-        duration_ms: null,
-        duration_provenance: null,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:3`,
-        run_id: id,
-        sequence: 3,
-        occurred_at: "2026-08-12T12:02:00.000Z",
-        type: "run.finished",
-        phase: "planning",
-        status: "completed",
-        duration_ms: duration,
-        duration_provenance: "observed",
-      },
-    ];
-    for (const [id, specId, prdId, tokens, cost, duration] of [
-      ["RUN-UNIQUE", "SPEC-UNIQUE", "PRD-UNIQUE", 7, 3, 120_000],
-      ["RUN-SHARED", "SPEC-SHARED", "PRD-SHARED", 11, 5, 60_000],
-      ["RUN-PRD-ONLY", null, "PRD-ONLY", 13, 6, 90_000],
-      ["RUN-NO-MACRO", null, null, 17, 8, 30_000],
-    ] as const)
-      await writeFile(
-        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
-        `${run(id, specId, prdId, tokens, cost, duration)
-          .map((record) => JSON.stringify(record))
-          .join("\n")}\n`,
-        "utf8",
-      );
-    await rebuildSqliteReadModel(root);
-    const filesystem = new SqliteReadModelFileSystem(root);
-    const tasks = filesystem.summaryPage("task", { from: null, to: null }, 0, 10).rows;
-    expect(tasks).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-UNIQUE",
-        invocation_count: 1,
-        total_duration: 62_500,
-        total_tokens: 7,
-        total_cost_brl: 3,
-      }),
-    );
-    expect(tasks).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-SHARED-A",
-        invocation_count: null,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      }),
-    );
-    expect(tasks).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-SHARED-B",
-        invocation_count: null,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      }),
-    );
-    expect(tasks).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-PRD-ONLY",
-        invocation_count: 1,
-        total_duration: 32_500,
-        total_tokens: 13,
-        total_cost_brl: 6,
-      }),
-    );
-    expect(tasks).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-NO-MACRO",
-        invocation_count: null,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      }),
-    );
-    filesystem.close();
-  });
-
-  it("counts every root execution day and returns task duration leaders", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
-    for (const kind of ["tasks", "specs", "prds"])
-      await mkdir(join(root, ".agents", "records", kind, "2026", "08"), { recursive: true });
-    await mkdir(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "evidence"),
-      { recursive: true },
-    );
-    await mkdir(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "validations",
-      ),
-      { recursive: true },
-    );
-    await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(
-      join(root, ".agents", "config", "project.yaml"),
-      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "config", "framework.lock.yaml"),
-      "lock_version: 1\nframework:\n  version: 2.2.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
-      "utf8",
-    );
-    const run = (
-      id: string,
-      day: string,
-      task: string,
-      duration: number,
-      time = "12:00:00.000Z",
-      spec: string | null = null,
-      prd: string | null = null,
-    ) => [
-      {
-        schema_version: 2,
-        event_id: `${id}:1`,
-        run_id: id,
-        sequence: 1,
-        occurred_at: `${day}T${time}`,
-        type: "run.started",
-        attribution_status: "attributed",
-        phase: "execution",
-        run_role: "orchestrator",
-        run_purpose: "execution",
-        requires_finalizer: false,
-        execution_kind: "delivery",
-        execution_eligibility: ["delivery"],
-        entrypoint: "task",
-        work_type: "new",
-        storage_mode: "tracked_sanitized",
-        client: "codex",
-        agent: "agent",
-        agent_name: "agent",
-        provider: "openai",
-        model: "gpt-5",
-        reasoning_effort: null,
-        client_thread_id: id,
-        client_turn_id: id,
-        conversation_id: `CONV-${id}`,
-        execution_id: `EXEC-${id}`,
-        task_id: task,
-        spec_id: spec,
-        prd_id: prd,
-        change_id: null,
-        parent_run_id: null,
-        continuation_of_run_id: null,
-        retry_of_run_id: null,
-        agent_invocation_id: `AINV-${id}`,
-        root_agent_invocation_id: `AINV-${id}`,
-        parent_agent_invocation_id: null,
-        invocation_kind: "orchestrator",
-        delegation_depth: 0,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:2`,
-        run_id: id,
-        sequence: 2,
-        occurred_at: `${day}T12:00:01.000Z`,
-        type: "usage.recorded",
-        phase: "execution",
-        activity_kind: "model_usage",
-        classification_source: "explicit",
-        tokens: {
-          input: 1,
-          cached_input: 0,
-          output: 1,
-          reasoning: 0,
-          total: 2,
-          source: "provider_reported",
-        },
-        cost: { usd: 1, brl: 5, fx_rate: 5 },
-        provider: "openai",
-        model: "gpt-5",
-        source_segment_key: id,
-        model_call_id: `MCALL-${id}`,
-        runtime: { reasoning_effort: null, service_tier: null },
-        supersedes_event_id: null,
-        duration_ms: null,
-        duration_provenance: null,
-      },
-      {
-        schema_version: 2,
-        event_id: `${id}:3`,
-        run_id: id,
-        sequence: 3,
-        occurred_at: `${day}T12:00:02.000Z`,
-        type: "run.finished",
-        phase: "execution",
-        status: "completed",
-        duration_ms: duration,
-        duration_provenance: "observed",
-      },
-    ];
-    for (const [id, records] of [
-      [
-        "RUN-R1",
-        run("RUN-R1", "2026-08-01", "TASK-A", 600_000, "12:00:00.000Z", "SPEC-A", "PRD-A"),
-      ],
-      [
-        "RUN-R2",
-        run("RUN-R2", "2026-08-02", "TASK-B", 1_200_000, "12:00:00.000Z", "SPEC-B", "PRD-A"),
-      ],
-      [
-        "RUN-R3",
-        run("RUN-R3", "2026-08-02", "TASK-B", 1_200_000, "12:10:00.000Z", "SPEC-B", "PRD-A"),
-      ],
-    ] as const) {
-      await writeFile(
-        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
-        `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
-        "utf8",
-      );
-    }
-    await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "evidence",
-        "EVD-1.md",
-      ),
-      "---\nid: EVD-1\nobserved_at: 2026-08-01T12:00:00.000Z\n---\n# Evidence\n",
-      "utf8",
-    );
-    await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-ART",
-        "artifacts",
-        "validations",
-        "VAL-1.md",
-      ),
-      "---\nid: VAL-1\nexecuted_at: 2026-08-02T12:00:00.000Z\n---\n# Validation\n",
-      "utf8",
-    );
-    for (const [kind, id] of [
-      ["tasks", "TASK-NO-RUN"],
-      ["specs", "SPEC-NO-RUN"],
-      ["prds", "PRD-NO-RUN"],
-    ] as const)
-      await writeFile(
-        join(root, ".agents", "records", kind, "2026", "08", `${id}.md`),
-        `---\nid: ${id}\ntitle: ${id}\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# ${id}\n`,
-        "utf8",
-      );
-    await rebuildSqliteReadModel(root);
-    const filesystem = new SqliteReadModelFileSystem(root);
-    expect(filesystem.firstFoldAggregate({ from: null, to: null }).execution_day_count).toBe(2);
-    expect(filesystem.firstFoldAggregate({ from: null, to: null }).duration_ms).toBe(2_400_000);
-    expect(filesystem.topTasks({ from: null, to: null })).toMatchObject([
-      { task_id: "TASK-B", duration_ms: 1_800_000 },
-      { task_id: "TASK-A", duration_ms: 600_000 },
-    ]);
-    expect(filesystem.summaryPage("task", { from: null, to: null }, 0, 50).rows).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-B",
-        invocation_count: 2,
-        total_duration: 1_800_000,
-        total_tokens: 4,
-        total_cost_brl: 10,
-      }),
-    );
-    expect(filesystem.summaryPage("spec", { from: null, to: null }, 0, 50).rows).toContainEqual(
-      expect.objectContaining({
-        id: "SPEC-B",
-        invocation_count: 2,
-        total_duration: 1_800_000,
-        total_tokens: 4,
-        total_cost_brl: 10,
-      }),
-    );
-    expect(filesystem.summaryPage("prd", { from: null, to: null }, 0, 50).rows).toContainEqual(
-      expect.objectContaining({
-        id: "PRD-A",
-        invocation_count: 3,
-        total_duration: 2_400_000,
-        total_tokens: 6,
-        total_cost_brl: 15,
-      }),
-    );
-    expect(filesystem.summaryPage("task", { from: null, to: null }, 0, 50).rows).toContainEqual(
-      expect.objectContaining({
-        id: "TASK-NO-RUN",
-        invocation_count: null,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      }),
-    );
-    const allTime = filesystem.firstFoldAllTime();
-    expectPersistedFirstFoldCaches(root, allTime, filesystem.firstFoldBoardAllTime());
-    expect(allTime.aggregate).toMatchObject({
-      start_day: "2026-08-01",
-      end_day: "2026-08-03",
-      task_count: 3,
-      spec_count: 3,
-      prd_count: 2,
-      total_run_count: 3,
-      duration_ms: 2_400_000,
-      total_tokens: 6,
-      cost_brl: 15,
-      execution_day_count: 2,
-    });
-    expect(allTime.task_status_counts).toEqual({ draft: 3 });
-    // The served quick projection uses this deliberately lean subset. It must
-    // remain factually identical to the rich projection for the six cards and
-    // two first-fold charts, while leaving rankings and macro metrics lazy.
-    const viewport = filesystem.firstFoldViewportAllTime();
-    expect(viewport.aggregate).toEqual(allTime.aggregate);
-    expect(viewport.task_status_counts).toEqual(allTime.task_status_counts);
-    expect(viewport.task_risk_counts).toEqual(allTime.task_risk_counts);
-    expect(allTime.top_tasks).toMatchObject([
-      { rank: 1, task_id: "TASK-B", total_duration_ms: 1_800_000 },
-      { rank: 2, task_id: "TASK-A", total_duration_ms: 600_000 },
-    ]);
-    expect(filesystem.firstFoldTopTasksAllTime()).toEqual(allTime.top_tasks);
-    expect(
-      projectAllTimeTopTasks([
-        {
-          task_id: "TASK-NO-USAGE",
-          total_duration_ms: null,
-          total_tokens: null,
-          total_cost_usd: null,
-          total_cost_brl: null,
-          total_run_count: 1,
-        },
-      ]),
-    ).toEqual([
-      {
-        task_id: "TASK-NO-USAGE",
-        duration_ms: null,
-        total_tokens: null,
-        total_cost_usd: null,
-        cost_brl: null,
-        run_count: 1,
-      },
-    ]);
-    const app = createDashboardApp(root, "test-session", undefined, { filesystem });
-    const allTimeQuick = await app.request("/api/v2/operations?scope=quick", {
-      headers: { "x-zaip-session": "test-session" },
-    });
-    const boundedQuick = await app.request(
-      "/api/v2/operations?scope=quick&from=2026-08-02&to=2026-08-02",
-      { headers: { "x-zaip-session": "test-session" } },
-    );
-    const topTasks = (await allTimeQuick.json()) as {
-      summary: { overview_metrics?: { top_tasks?: unknown[] } };
-    };
-    const boundedTopTasks = (await boundedQuick.json()) as {
-      summary: { overview_metrics?: { top_tasks?: unknown[] } };
-    };
-    expect(topTasks.summary.overview_metrics?.top_tasks).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          task_id: "TASK-B",
-          duration_ms: 1_800_000,
-          total_tokens: 4,
-          cost_brl: 10,
-        }),
-      ]),
-    );
-    expect(boundedTopTasks.summary.overview_metrics?.top_tasks).toEqual([
-      expect.objectContaining({
-        task_id: "TASK-B",
-        duration_ms: 1_800_000,
-        total_tokens: 4,
-        cost_brl: 10,
-      }),
-    ]);
-    // A new calendar month after this immutable snapshot has no factual rows.
-    // It must be a fast exact empty projection, not a slow scan caused by the
-    // default date range changing at midnight on the first day of the month.
-    const nextMonthQuick = await app.request(
-      "/api/v2/operations?scope=quick&from=2026-09-01&to=2026-09-01",
-      { headers: { "x-zaip-session": "test-session" } },
-    );
-    const nextMonth = (await nextMonthQuick.json()) as {
-      summary: {
-        run_count: number;
-        task_count: number;
-        overview_metrics: { tokens: number | null; duration_ms: number | null };
-      };
-    };
-    expect(nextMonth.summary).toMatchObject({
-      run_count: 0,
-      task_count: 0,
-      overview_metrics: { tokens: null, duration_ms: null },
-    });
-    expect(allTime.macro_metrics.specs).toMatchObject({
-      entity_count: 3,
-      status_counts: { planning: 3 },
-      classification_counts: { structured: 2 },
-      total_run_count: 3,
-      total_duration_ms: 2_400_000,
-      total_tokens: 6,
-      total_cost_brl: 15,
-      average_duration_ms: 800_000,
-    });
-    expect(allTime.macro_metrics.specs.top_entities.slice(0, 2)).toMatchObject([
-      { rank: 1, entity_id: "SPEC-B", total_duration_ms: 1_800_000 },
-      { rank: 2, entity_id: "SPEC-A", total_duration_ms: 600_000 },
-    ]);
-    expect(allTime.macro_metrics.prds).toMatchObject({
-      entity_count: 2,
-      status_counts: { definition: 2 },
-      classification_counts: { structured: 1 },
-      total_run_count: 3,
-      total_duration_ms: 2_400_000,
-      total_tokens: 6,
-      total_cost_brl: 15,
-      average_duration_ms: 1_200_000,
-    });
-    const operationDays = filesystem.dailyPeriods({ from: null, to: null });
-    expect(Object.keys(operationDays)).toEqual(["2026-08-01", "2026-08-02", "2026-08-03"]);
-    expect(operationDays["2026-08-02"]).toMatchObject({
-      runs: 2,
-      specs: 1,
-      tasks: 1,
-      validations: 1,
-      evidences: 0,
-      usage: {
-        total_tokens: { known_sum: 4, unknown: 0 },
-        cost: { known_sum: 10, unknown: 0 },
-      },
-      duration: { known_sum: 1_800_000, unknown: 0 },
-    });
-    expect(filesystem.viewPage("operations_daily", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({
-        day: "2026-08-02",
-        task_count: 1,
-        spec_count: 1,
-        validation_count: 1,
-        evidence_count: 0,
-        total_run_count: 2,
-        operations_total_duration: 1_800_000,
-        total_tokens: 4,
-        total_cost_brl: 10,
-      }),
-    );
-    for (const [view, key] of [
-      ["operations_monthly", "2026-08"],
-      ["operations_annual", "2026"],
-    ] as const) {
-      expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
-        expect.objectContaining({
-          period_key: key,
-          prd_count: 2,
-          spec_count: 3,
-          task_count: 3,
-          validation_count: 1,
-          evidence_count: 1,
-          total_run_count: 3,
-          operations_total_duration: 2_400_000,
-          total_tokens: 6,
-          total_cost_brl: 15,
-        }),
-      );
-    }
-    for (const view of ["operations_monthly", "operations_annual"] as const) {
-      expect(
-        filesystem.viewPage(view, {
-          from: "2026-08-02T03:00:00.000Z",
-          to: "2026-08-02T23:59:59.999Z",
-          limit: 50,
-        }).rows,
-      ).toEqual([
-        expect.objectContaining({
-          start_day: "2026-08-02",
-          end_day: "2026-08-02",
-          total_run_count: 2,
-          invocation_count: 2,
-          operations_total_duration: 1_800_000,
-          total_tokens: 4,
-          total_cost_usd: 2,
-          total_cost_brl: 10,
-        }),
-      ]);
-    }
-    for (const [view, key, counts] of [
-      [
-        "cost_monitor_daily",
-        "2026-08-02",
-        { prd_count: 0, spec_count: 1, task_count: 1, validation_count: 1, evidence_count: 0 },
-      ],
-      [
-        "cost_monitor_monthly",
-        "2026-08",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
-      ],
-      [
-        "cost_monitor_annual",
-        "2026",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
-      ],
-    ] as const) {
-      expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
-        expect.objectContaining({ key, ...counts }),
-      );
-    }
-    expect(filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 1 }),
-    );
-    expect(filesystem.viewPage("cost_monitor_monthly", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 3 }),
-    );
-    expect(filesystem.viewPage("cost_monitor_annual", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 3 }),
-    );
-    const annualCostPage = filesystem.viewPage("cost_monitor_annual", { limit: 50 });
-    const dailyCostRows = filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows;
-    const pagedDailyCostPage = filesystem.viewPage("cost_monitor_daily", { limit: 1 });
-    expect(pagedDailyCostPage).toMatchObject({
-      total_count: dailyCostRows.length,
-      rows: [expect.any(Object)],
-    });
-    expect(pagedDailyCostPage.totals).toMatchObject({
-      total_tokens: dailyCostRows.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
-      total_cost_brl: dailyCostRows.reduce((sum, row) => sum + Number(row.total_cost_brl ?? 0), 0),
-      total_duration: dailyCostRows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0),
-    });
-    expect(annualCostPage).toMatchObject({
-      total_count: 1,
-      rows: [expect.objectContaining({ key: "2026" })],
-    });
-    const annualCostRow = annualCostPage.rows[0];
-    if (annualCostRow === undefined) throw new Error("Expected the consolidated 2026 Cost row");
-    for (const metric of [
-      "prd_count",
-      "spec_count",
-      "task_count",
-      "validation_count",
-      "evidence_count",
-      "total_run_count",
-      "total_duration",
-      "duration_known",
-      "total_tokens",
-      "total_cost_usd",
-      "total_cost_brl",
-    ] as const) {
-      const observed = dailyCostRows
-        .map((row) => row[metric])
-        .filter((value): value is number => typeof value === "number");
-      expect(annualCostRow[metric]).toBe(
-        observed.length === 0 ? null : observed.reduce((sum, value) => sum + value, 0),
-      );
-    }
-    expect(
-      filesystem.viewPage("cost_monitor_daily", { limit: 50, provider: "openai" }).rows,
-    ).toContainEqual(
-      expect.objectContaining({
-        key: "2026-08-02",
-        prd_count: 0,
-        spec_count: 1,
-        task_count: 1,
-        validation_count: 1,
-        evidence_count: 0,
-      }),
-    );
-    for (const [view, entityCount] of [
-      ["cost_monitor_tasks", 2],
-      ["cost_monitor_specs", 3],
-      ["cost_monitor_prds", 2],
-      ["cost_monitor_conversations", 3],
-    ] as const) {
-      const page = filesystem.viewPage(view, { limit: 1 });
-      // The subtotal is computed before pagination and reconciles the full
-      // filtered population, rather than the single visible row.
-      expect(page).toMatchObject({ total_count: entityCount, rows: [expect.any(Object)] });
-      expect(page.totals).toEqual({
-        entity_count: entityCount,
-        invocation_count: 3,
-        total_duration: 2_400_000,
-        total_tokens: 6,
-        total_cost_usd: 3,
-        total_cost_brl: 15,
-      });
-    }
-    expect(
-      filesystem.viewPage("cost_monitor_tasks", {
-        from: "2026-08-02",
-        to: "2026-08-02",
-        query: "TASK-B",
-        limit: 1,
-      }).totals,
-    ).toEqual({
-      entity_count: 1,
-      invocation_count: 2,
-      total_duration: 1_800_000,
-      total_tokens: 4,
-      total_cost_usd: 2,
-      total_cost_brl: 10,
-    });
-    // The compact Cost Monitor tables share the canonical macro population
-    // with their big numbers.  A macro with no direct invocation must remain
-    // paginable and retain unavailable financial facts as null.
-    expect(
-      filesystem.viewPage("cost_monitor_specs", { query: "SPEC-NO-RUN", limit: 1 }),
-    ).toMatchObject({
-      total_count: 1,
-      totals: {
-        entity_count: 1,
-        invocation_count: 0,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      },
-      rows: [
-        expect.objectContaining({
-          id: "SPEC-NO-RUN",
-          title: "SPEC-NO-RUN",
-          invocation_count: 0,
-          total_duration: null,
-          total_tokens: null,
-          total_cost_brl: null,
-        }),
-      ],
-    });
-    expect(
-      filesystem.viewPage("cost_monitor_prds", { query: "PRD-NO-RUN", limit: 1 }),
-    ).toMatchObject({
-      total_count: 1,
-      totals: {
-        entity_count: 1,
-        invocation_count: 0,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
-      },
-      rows: [
-        expect.objectContaining({
-          id: "PRD-NO-RUN",
-          title: "PRD-NO-RUN",
-          invocation_count: 0,
-          total_duration: null,
-          total_tokens: null,
-          total_cost_brl: null,
-        }),
-      ],
-    });
-    for (const view of [
-      "cost_monitor_tasks",
-      "cost_monitor_specs",
-      "cost_monitor_prds",
-      "cost_monitor_conversations",
-    ] as const) {
-      const filtered = filesystem.viewPage(view, {
-        phase: "execution",
-        provider: "openai",
-        model: "gpt-5",
-        limit: 1,
-      });
-      // Dimensional membership and the subtotal share one pre-pagination
-      // invocation population for every compact lifecycle view.
-      expect(filtered.rows).toHaveLength(1);
-      expect(filtered.totals).toMatchObject({
-        invocation_count: 3,
-        total_tokens: 6,
-        total_cost_brl: 15,
-      });
-    }
-    expect(filesystem.viewPage("cost_monitor_tasks", { workType: "new", limit: 1 })).toMatchObject({
-      total_count: 0,
-      rows: [],
-    });
-    expect(filesystem.firstFoldAllTime()).toBe(allTime);
-    filesystem.close();
-
-    // Period membership follows the canonical macro day, not an invocation
-    // that happened on another day. Search accepts either the macro ID or
-    // title, and totals are still calculated before its one-row page.
-    await writeFile(
-      join(root, ".agents", "records", "specs", "2026", "08", "SPEC-CANONICAL-DAY.md"),
-      "---\nid: SPEC-CANONICAL-DAY\ntitle: Macro by canonical title\nstatus: draft\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n# Macro\n",
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY.jsonl"),
-      `${run(
-        "RUN-CANONICAL-DAY",
-        "2026-08-02",
-        "TASK-CANONICAL-DAY",
-        1_000,
-        "12:30:00.000Z",
-        "SPEC-CANONICAL-DAY",
-      )
-        .map((record) => JSON.stringify(record))
-        .join("\n")}\n`,
-      "utf8",
-    );
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL-DAY-LATE.jsonl"),
-      `${run(
-        "RUN-CANONICAL-DAY-LATE",
-        "2026-08-04",
-        "TASK-CANONICAL-DAY-LATE",
-        1_000,
-        "12:30:00.000Z",
-        "SPEC-CANONICAL-DAY",
-      )
-        .map((record) => JSON.stringify(record))
-        .join("\n")}\n`,
-      "utf8",
-    );
-    await rebuildSqliteReadModel(root);
-    const canonicalDayFilesystem = new SqliteReadModelFileSystem(root);
-    expect(
-      canonicalDayFilesystem.viewPage("cost_monitor_specs", {
-        from: "2026-08-03",
-        to: "2026-08-03",
-        query: "canonical title",
-        limit: 1,
-      }),
-    ).toMatchObject({
-      total_count: 1,
-      totals: { entity_count: 1, invocation_count: 0, total_tokens: null, total_cost_brl: null },
-      rows: [
-        expect.objectContaining({
-          id: "SPEC-CANONICAL-DAY",
-          invocation_count: 0,
-          total_tokens: null,
-          total_cost_brl: null,
-        }),
-      ],
-    });
-    expect(
-      canonicalDayFilesystem.viewPage("cost_monitor_specs", {
-        from: "2026-08-02",
-        to: "2026-08-02",
-        query: "SPEC-CANONICAL-DAY",
-        limit: 1,
-      }),
-    ).toMatchObject({ total_count: 0, rows: [] });
-    canonicalDayFilesystem.close();
-
-    // A large result set keeps its subtotal for all 270 matching Tasks while
-    // the page transports only 50 records.
-    for (let index = 0; index < 270; index += 1) {
-      const id = `RUN-PAGE-${index}`;
-      await writeFile(
-        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
-        `${run(id, "2026-08-04", `TASK-PAGE-${index}`, 1_000)
-          .map((record) => JSON.stringify(record))
-          .join("\n")}\n`,
-        "utf8",
-      );
-    }
-    await rebuildSqliteReadModel(root);
-    const pageFilesystem = new SqliteReadModelFileSystem(root);
-    const paged = pageFilesystem.viewPage("cost_monitor_tasks", {
-      from: "2026-08-04",
-      to: "2026-08-04",
-      query: "TASK-PAGE-",
-      offset: 50,
-      limit: 50,
-    });
-    expect(paged).toMatchObject({ total_count: 270, has_more: true });
-    expect(paged.rows).toHaveLength(50);
-    expect(paged.totals).toEqual({
-      entity_count: 270,
-      invocation_count: 270,
-      total_duration: 1_000,
-      total_tokens: 540,
-      total_cost_usd: 270,
-      total_cost_brl: 1_350,
-    });
-    pageFilesystem.close();
-  });
-
-  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/sqlite/zaip-aios-dashboard.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();
-  });
 });