@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -1,15 +1,24 @@
-import { mkdir, mkdtemp, readFile, readdir, rename, utimes, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readdir, readFile, rename, utimes, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { afterEach, describe, expect, it } from "vitest";
 import { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
-import { allocateAttributedTokenActiveMs, rebuildSqliteReadModel, sourceFingerprint, SqliteReadModelFileSystem } from "./sqlite-read-model.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[] = [];
-// Windows can deny SQLite's sidecar files below the system TEMP directory.
-// Keep disposable fixtures in the workspace-local test area instead; each
-// test still receives its own root and never touches the live read model.
-const sqliteTestTempRoot = join(resolve(import.meta.dirname, "../../../../../.."), ".tmp", "sqlite-read-model-tests");
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
 async function createSqliteTestRoot(): Promise<string> {
   await mkdir(sqliteTestTempRoot, { recursive: true });
   return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
@@ -23,7 +32,6 @@ afterEach(async () => {
       ),
   );
 });
-
 describe("SQLite dashboard read model", () => {
   it("snapshots sorted eligible canonical sources once for fingerprinting and ingestion", async () => {
     const root = await createSqliteTestRoot();
@@ -33,7 +41,11 @@ describe("SQLite dashboard read model", () => {
     await mkdir(join(root, ".agents", "records", "tasks", "nested"), { recursive: true });
     await mkdir(join(root, ".agents", "records", "telemetry"), { recursive: true });
     await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
     await writeFile(included, "# included\n", "utf8");
     await writeFile(excluded, "ignored\n", "utf8");
 
@@ -50,13 +62,42 @@ describe("SQLite dashboard read model", () => {
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 2 });
   });
 
+  it("accepts only the canonical C3D4 historical assignment among lifecycle files", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const attributionRoot = join(
+      root,
+      ".agents",
+      "records",
+      "lifecycle",
+      "historical-developer-attribution",
+    );
+    await mkdir(attributionRoot, { recursive: true });
+    await mkdir(join(root, ".agents", "records", "lifecycle", "views"), { 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(attributionRoot, "HDA-2026-08-29-ZAIP-AI-C3D4.json"), "{}\n");
+    await writeFile(join(root, ".agents", "records", "lifecycle", "views", "foreign.json"), "{}\n");
+
+    const snapshot = await sourceFingerprint(root);
+    expect(snapshot.candidates.map((candidate) => candidate.source)).toContain(
+      ".agents/records/lifecycle/historical-developer-attribution/HDA-2026-08-29-ZAIP-AI-C3D4.json",
+    );
+    expect(snapshot.candidates.map((candidate) => candidate.source)).not.toContain(
+      ".agents/records/lifecycle/views/foreign.json",
+    );
+  });
   it("uses a current-schema seed after a canonical change", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     const task = join(root, ".agents", "records", "tasks", "task.md");
     await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
     await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
     await writeFile(task, "# original\n", "utf8");
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
     await writeFile(task, "# changed canonically\n", "utf8");
@@ -65,7 +106,14 @@ describe("SQLite dashboard read model", () => {
     try {
       process.env.ZAIP_SQLITE_DB_PATH = join(root, ".local", "dashboard-sqlite", "next.sqlite");
       process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
-      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "stale_seed", files: 2 });
+      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+        cache: "stale_seed",
+        files: 2,
+      });
+      await expect(rebuildSqliteReadModel(root, { forceCanonical: true })).resolves.toMatchObject({
+        cache: "rebuilt",
+        files: 2,
+      });
     } finally {
       if (previousPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
       else process.env.ZAIP_SQLITE_DB_PATH = previousPath;
@@ -79,55 +127,103 @@ describe("SQLite dashboard read model", () => {
     roots.push(root);
     await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
     await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
     const path = join(root, ".local", "dashboard-sqlite", "read-model.sqlite");
     const database = new DatabaseSync(path);
-    database.prepare("UPDATE zaip_aios_activities SET payload_json=? WHERE payload_type='first_fold_monthly_quick_cache'").run(JSON.stringify({
-      from_day: "2026-08-01", to_day: "2026-08-18", source_latest_day: "2026-08-30",
-      aggregate: { days: 0, total_run_count: 0, agent_invocation_count: 0, llm_call_count: null, duration_ms: null, total_tokens: null, cost_brl: null, execution_day_count: 0 },
-      pages: { task: [], spec: [], prd: [] }, top_tasks: [],
-    }));
+    database
+      .prepare(
+        "UPDATE zaip_aios_activities SET payload_json=? WHERE payload_type='first_fold_monthly_quick_cache'",
+      )
+      .run(
+        JSON.stringify({
+          from_day: "2026-08-01",
+          to_day: "2026-08-18",
+          source_latest_day: "2026-08-30",
+          aggregate: {
+            days: 0,
+            total_run_count: 0,
+            agent_invocation_count: 0,
+            llm_call_count: null,
+            duration_ms: null,
+            total_tokens: null,
+            cost_brl: null,
+            execution_day_count: 0,
+          },
+          pages: { task: [], spec: [], prd: [] },
+          top_tasks: [],
+        }),
+      );
     database.close();
     const filesystem = new SqliteReadModelFileSystem(root);
     try {
-      expect(filesystem.firstFoldMonthlyQuick({ from: "2026-08-01", to: "2026-08-18" })).not.toBeNull();
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2026-08-01", to: "2026-08-18" }),
+      ).not.toBeNull();
       expect(filesystem.firstFoldMonthlyQuick({ from: "2026-08-01", to: "2026-08-19" })).toBeNull();
-      expect(filesystem.firstFoldMonthlyQuick({ from: "2026-09-01", to: "2026-09-01" })).toMatchObject({
-        aggregate: { total_run_count: 0 }, pages: { task: [], spec: [], prd: [] },
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2026-09-01", to: "2026-09-01" }),
+      ).toMatchObject({
+        aggregate: { total_run_count: 0 },
+        pages: { task: [], spec: [], prd: [] },
       });
-    } finally { filesystem.close(); }
+    } finally {
+      filesystem.close();
+    }
   });
 
   it("treats an empty snapshot as an exact empty later-month projection", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
     const filesystem = new SqliteReadModelFileSystem(root);
     try {
-      expect(filesystem.firstFoldMonthlyQuick({ from: "2099-01-01", to: "2099-01-01" })).toMatchObject({
-        aggregate: { total_run_count: 0 }, pages: { task: [], spec: [], prd: [] },
+      expect(
+        filesystem.firstFoldMonthlyQuick({ from: "2099-01-01", to: "2099-01-01" }),
+      ).toMatchObject({
+        aggregate: { total_run_count: 0 },
+        pages: { task: [], spec: [], prd: [] },
       });
-    } finally { filesystem.close(); }
+    } finally {
+      filesystem.close();
+    }
   });
 
-  it("does not serve a schema 59 seed during the one-time SQLite cache migration", async () => {
+  it("does not serve a prior-schema seed during the one-time SQLite cache migration", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
     await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n", "utf8");
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
     await writeFile(join(root, ".agents", "records", "tasks", "task.md"), "# task\n", "utf8");
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
     const cacheDirectory = join(root, ".local", "dashboard-sqlite", "cache");
-    const current = (await readdir(cacheDirectory)).find((entry) => entry.startsWith("v60-") && entry.endsWith(".sqlite"));
+    const current = (await readdir(cacheDirectory)).find(
+      (entry) => /^v\d+-/.test(entry) && entry.endsWith(".sqlite"),
+    );
     expect(current).toBeDefined();
-    const legacy = join(cacheDirectory, current!.replace("v60-", ""));
+    const legacy = join(cacheDirectory, current!.replace(/^v\d+-/, ""));
     await rename(join(cacheDirectory, current!), legacy);
     const oldSeed = new DatabaseSync(legacy);
-    oldSeed.prepare("UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', '59') WHERE payload_type='metadata' AND json_extract(payload_json, '$.key')='schema_version'").run();
+    oldSeed
+      .prepare(
+        "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', '65') WHERE payload_type='metadata' AND json_extract(payload_json, '$.key')='schema_version'",
+      )
+      .run();
     oldSeed.close();
     const priorPath = process.env.ZAIP_SQLITE_DB_PATH;
     const priorSeed = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
@@ -145,19 +241,41 @@ describe("SQLite dashboard read model", () => {
 
   it("rateia sobreposição e virada de dia na fato temporal aditiva", () => {
     const overlap = allocateAttributedTokenActiveMs([
-      { activityRowId: "A", startMs: Date.parse("2026-08-10T12:00:00.000Z"), endMs: Date.parse("2026-08-10T13:00:00.000Z") },
-      { activityRowId: "B", startMs: Date.parse("2026-08-10T12:30:00.000Z"), endMs: Date.parse("2026-08-10T13:30:00.000Z") },
+      {
+        activityRowId: "A",
+        startMs: Date.parse("2026-08-10T12:00:00.000Z"),
+        endMs: Date.parse("2026-08-10T13:00:00.000Z"),
+      },
+      {
+        activityRowId: "B",
+        startMs: Date.parse("2026-08-10T12:30:00.000Z"),
+        endMs: Date.parse("2026-08-10T13:30:00.000Z"),
+      },
     ]);
     expect(overlap.reduce((sum, fact) => sum + fact.value, 0)).toBe(5_400_000);
-    expect(overlap.filter((fact) => fact.activityRowId === "A").reduce((sum, fact) => sum + fact.value, 0)).toBe(2_700_000);
-    expect(overlap.filter((fact) => fact.activityRowId === "B").reduce((sum, fact) => sum + fact.value, 0)).toBe(2_700_000);
+    expect(
+      overlap
+        .filter((fact) => fact.activityRowId === "A")
+        .reduce((sum, fact) => sum + fact.value, 0),
+    ).toBe(2_700_000);
+    expect(
+      overlap
+        .filter((fact) => fact.activityRowId === "B")
+        .reduce((sum, fact) => sum + fact.value, 0),
+    ).toBe(2_700_000);
     const midnight = allocateAttributedTokenActiveMs([
-      { activityRowId: "MID", startMs: Date.parse("2026-08-11T02:30:00.000Z"), endMs: Date.parse("2026-08-11T03:30:00.000Z") },
+      {
+        activityRowId: "MID",
+        startMs: Date.parse("2026-08-11T02:30:00.000Z"),
+        endMs: Date.parse("2026-08-11T03:30:00.000Z"),
+      },
     ]);
-    expect(midnight).toEqual(expect.arrayContaining([
-      expect.objectContaining({ day: "2026-08-10", value: 1_800_000 }),
-      expect.objectContaining({ day: "2026-08-11", value: 1_800_000 }),
-    ]));
+    expect(midnight).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ day: "2026-08-10", value: 1_800_000 }),
+        expect.objectContaining({ day: "2026-08-11", value: 1_800_000 }),
+      ]),
+    );
   });
   it("projects canonical executions, conversations, changes and decisions without lifecycle aggregates", async () => {
     const root = await createSqliteTestRoot();
@@ -166,10 +284,9 @@ describe("SQLite dashboard read model", () => {
     await mkdir(join(root, ".agents", "records", "executions", "2026", "08", "EXEC-1"), {
       recursive: true,
     });
-    await mkdir(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "decisions"),
-      { recursive: true },
-    );
+    await mkdir(join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "decisions"), {
+      recursive: true,
+    });
     await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
     await writeFile(
       join(root, ".agents", "records", "executions", "2026", "08", "EXEC-1", "execution.md"),
@@ -210,17 +327,7 @@ created_at: 2026-08-10T11:00:00.000Z
 `,
     );
     await writeFile(
-      join(
-        root,
-        ".agents",
-        "records",
-        "changes",
-        "2026",
-        "08",
-        "CHG-1",
-        "decisions",
-        "DEC-1.md",
-      ),
+      join(root, ".agents", "records", "changes", "2026", "08", "CHG-1", "decisions", "DEC-1.md"),
       `---
 schema_version: 2
 id: DEC-1
@@ -239,7 +346,16 @@ created_at: 2026-08-10T11:01:00.000Z
     const filesystem = new SqliteReadModelFileSystem(root);
     expect(filesystem.viewPage("operations_executions", { limit: 100 })).toMatchObject({
       total_count: 1,
-      rows: [{ execution_id: "EXEC-1", conversation_id: "CONV-1", invocation_count: 0, duration_ms: null, duration_provenance: "unavailable", lifecycle_elapsed_ms: 300_000 }],
+      rows: [
+        {
+          execution_id: "EXEC-1",
+          conversation_id: "CONV-1",
+          invocation_count: 0,
+          duration_ms: null,
+          duration_provenance: "unavailable",
+          lifecycle_elapsed_ms: 300_000,
+        },
+      ],
     });
     expect(filesystem.viewPage("operations_conversations", { limit: 100 })).toMatchObject({
       total_count: 1,
@@ -253,8 +369,8 @@ created_at: 2026-08-10T11:01:00.000Z
       total_count: 1,
       rows: [{ id: "DEC-1", title: "Canonical decision", scope_id: "CHG-1" }],
     });
-    // Unfiltered Operations pagination is served from one immutable
-    // generation-local query result, while retaining the public page contract.
+    // Operations pagination stays inside SQLite even with no filters: the
+    // browser receives only its requested page, never the whole work union.
     const workListFirst = filesystem.viewPage("operations_work_list", { limit: 1, offset: 0 });
     const workListNext = filesystem.viewPage("operations_work_list", { limit: 1, offset: 1 });
     expect(workListFirst.total_count).toBe(workListNext.total_count);
@@ -312,30 +428,84 @@ created_at: 2026-08-10T11:01:00.000Z
     const events = [...expected.keys()].flatMap((agent, index) => {
       const runId = `RUN-AGENT-${index}`;
       const started = {
-        schema_version: 2, event_id: `${runId}:1`, run_id: runId, sequence: 1,
-        occurred_at: "2026-08-18T12:00:00.000Z", type: "run.started", attribution_status: "attributed",
-        phase: "execution", run_role: "subagent", run_purpose: "execution", requires_finalizer: false,
-        execution_kind: "delivery", execution_eligibility: ["delivery"], entrypoint: "task", work_type: "new",
-        storage_mode: "tracked_sanitized", client: "codex", agent, agent_name: agent, provider: "openai",
-        model: "gpt-5", reasoning_effort: null, client_thread_id: runId, client_turn_id: runId,
-        conversation_id: `CONV-${index}`, execution_id: `EXEC-${index}`, task_id: `TASK-${index}`,
-        spec_id: null, prd_id: null, change_id: null, parent_run_id: "RUN-ROOT", continuation_of_run_id: null,
-        retry_of_run_id: null, agent_invocation_id: `AINV-${index}`, root_agent_invocation_id: "AINV-ROOT",
-        parent_agent_invocation_id: "AINV-ROOT", invocation_kind: "delegated", delegation_depth: 1,
+        schema_version: 2,
+        event_id: `${runId}:1`,
+        run_id: runId,
+        sequence: 1,
+        occurred_at: "2026-08-18T12:00:00.000Z",
+        type: "run.started",
+        attribution_status: "attributed",
+        phase: "execution",
+        run_role: "subagent",
+        run_purpose: "execution",
+        requires_finalizer: false,
+        execution_kind: "delivery",
+        execution_eligibility: ["delivery"],
+        entrypoint: "task",
+        work_type: "new",
+        storage_mode: "tracked_sanitized",
+        client: "codex",
+        agent,
+        agent_name: agent,
+        provider: "openai",
+        model: "gpt-5",
+        reasoning_effort: null,
+        client_thread_id: runId,
+        client_turn_id: runId,
+        conversation_id: `CONV-${index}`,
+        execution_id: `EXEC-${index}`,
+        task_id: `TASK-${index}`,
+        spec_id: null,
+        prd_id: null,
+        change_id: null,
+        parent_run_id: "RUN-ROOT",
+        continuation_of_run_id: null,
+        retry_of_run_id: null,
+        agent_invocation_id: `AINV-${index}`,
+        root_agent_invocation_id: "AINV-ROOT",
+        parent_agent_invocation_id: "AINV-ROOT",
+        invocation_kind: "delegated",
+        delegation_depth: 1,
       };
       const usage = {
-        schema_version: 2, event_id: `${runId}:2`, run_id: runId, sequence: 2,
-        occurred_at: "2026-08-18T12:00:01.000Z", type: "usage.recorded", phase: "execution",
-        activity_kind: "model_usage", classification_source: "explicit",
-        tokens: { input: 1, cached_input: 0, output: 1, reasoning: 0, total: 2, source: "provider_reported" },
-        cost: { usd: 0.01, brl: 0.05, fx_rate: 5 }, provider: "openai", model: "gpt-5",
-        source_segment_key: runId, model_call_id: `MCALL-${index}`, runtime: { reasoning_effort: null, service_tier: null },
-        supersedes_event_id: null, duration_ms: null, duration_provenance: null,
+        schema_version: 2,
+        event_id: `${runId}:2`,
+        run_id: runId,
+        sequence: 2,
+        occurred_at: "2026-08-18T12:00:01.000Z",
+        type: "usage.recorded",
+        phase: "execution",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: 1,
+          cached_input: 0,
+          output: 1,
+          reasoning: 0,
+          total: 2,
+          source: "provider_reported",
+        },
+        cost: { usd: 0.01, brl: 0.05, fx_rate: 5 },
+        provider: "openai",
+        model: "gpt-5",
+        source_segment_key: runId,
+        model_call_id: `MCALL-${index}`,
+        runtime: { reasoning_effort: null, service_tier: null },
+        supersedes_event_id: null,
+        duration_ms: null,
+        duration_provenance: null,
       };
       const finished = {
-        schema_version: 2, event_id: `${runId}:3`, run_id: runId, sequence: 3,
-        occurred_at: "2026-08-18T12:01:00.000Z", type: "run.finished", phase: "execution",
-        status: "completed", duration_ms: 60_000, duration_provenance: "observed",
+        schema_version: 2,
+        event_id: `${runId}:3`,
+        run_id: runId,
+        sequence: 3,
+        occurred_at: "2026-08-18T12:01:00.000Z",
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
       };
       return [started, usage, finished];
     });
@@ -343,7 +513,10 @@ created_at: 2026-08-10T11:01:00.000Z
       [...expected.keys()].map((_, index) =>
         writeFile(
           join(root, ".agents", "records", "runs", "2026", "08", `RUN-AGENT-${index}.jsonl`),
-          `${events.slice(index * 3, index * 3 + 3).map((event) => JSON.stringify(event)).join("\n")}\n`,
+          `${events
+            .slice(index * 3, index * 3 + 3)
+            .map((event) => JSON.stringify(event))
+            .join("\n")}\n`,
         ),
       ),
     );
@@ -381,25 +554,87 @@ created_at: 2026-08-10T11:01: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: [] },
+          {
+            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,
+      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",
+      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"),
@@ -407,6 +642,7 @@ created_at: 2026-08-10T11:01:00.000Z
     );
     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: {
@@ -426,26 +662,40 @@ created_at: 2026-08-10T11:01:00.000Z
     await rebuildSqliteReadModel(root);
     const filesystem = new SqliteReadModelFileSystem(root);
     try {
-      expect(await filesystem.readText(".agents/config/project.yaml")).toBe("zaip:\n  enabled: true\n");
+      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;
+      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");
+      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();
+      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");
+      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();
     }
@@ -458,7 +708,7 @@ created_at: 2026-08-10T11:01:00.000Z
     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",
+      "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 = {
@@ -572,11 +822,24 @@ created_at: 2026-08-10T11:01:00.000Z
       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",
+      "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({
+    expect(
+      filesystem.costMonitorFactualDurationByDay({ from: null, to: null }).get("2026-08-01"),
+    ).toEqual({
       known_sum: 0,
       eligible_runs: 1,
       known_runs: 0,
@@ -589,7 +852,9 @@ created_at: 2026-08-10T11:01:00.000Z
     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 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"),
@@ -603,17 +868,117 @@ created_at: 2026-08-10T11:01: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: "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" }),
+      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" };
+    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`,
@@ -641,363 +1006,570 @@ created_at: 2026-08-10T11:01:00.000Z
     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: ready\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# Titulo semantico canonico\n",
+      "---\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) => [
-      { schema_version: 2, event_id: `${id}:1`, run_id: id, sequence: 1, occurred_at: "2026-08-08T12:00:00.000Z", type: "run.started", attribution_status: "attributed", phase: "execution", run_role: "orchestrator", run_purpose: "execution", requires_finalizer: false, execution_kind: "delivery", execution_eligibility: ["delivery"], entrypoint: "task", work_type: "new", storage_mode: "tracked_sanitized", client: "codex", agent: "agent", agent_name: "agent", provider: "openai", model: "gpt-a", reasoning_effort: null, client_thread_id: id, client_turn_id: id, conversation_id: `CONV-${id}`, execution_id: `EXEC-${id}`, task_id: taskId, spec_id: null, prd_id: null, change_id: null, parent_run_id: null, continuation_of_run_id: null, retry_of_run_id: null, agent_invocation_id: `AINV-${id}`, root_agent_invocation_id: `AINV-${id}`, parent_agent_invocation_id: null, invocation_kind: "orchestrator", delegation_depth: 0 },
-      { schema_version: 2, event_id: `${id}:2`, run_id: id, sequence: 2, occurred_at: "2026-08-08T12:00:30.000Z", type: "usage.recorded", phase: "execution", activity_kind: "model_usage", classification_source: "explicit", tokens: { input: tokens, cached_input: 0, output: 0, reasoning: 0, total: tokens, source: "provider_reported" }, cost: { usd: tokens / 100, brl: tokens / 20, fx_rate: 5 }, provider: "openai", model: "gpt-a", source_segment_key: id, model_call_id: `MCALL-${id}`, runtime: { reasoning_effort: null, service_tier: null }, supersedes_event_id: null, source_started_at: "2026-08-08T12:00:00.000Z", source_finished_at: "2026-08-08T12:01:00.000Z", duration_ms: null, duration_provenance: null },
-      { schema_version: 2, event_id: `${id}:3`, run_id: id, sequence: 3, occurred_at: "2026-08-08T12:01:00.000Z", type: "run.finished", phase: "execution", status: "completed", duration_ms: 60_000, duration_provenance: "observed" },
+    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).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", "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/dashboard-sqlite/read-model.sqlite"), { readOnly: true });
-    expect(snapshot.prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'").get()).toEqual({ value: "60" });
+    const snapshot = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      snapshot
+        .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
+        .get(),
+    ).toEqual({ value: "70" });
     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 }));
+      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("keeps a multi-provider and multi-model Run visible to both filtered financial and duration facts", async () => {
+  it("qualifies factual developer deliveries without inventing missing completion or coverage", 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",
-    );
+    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", "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: [] },
-        ],
-      }),
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
     );
-    const started = { schema_version: 2, event_id: "RUN-MULTI:1", run_id: "RUN-MULTI", sequence: 1, occurred_at: "2026-08-04T12:00:00.000Z", type: "run.started", attribution_status: "attributed", phase: "execution", run_role: "orchestrator", run_purpose: "execution", requires_finalizer: false, execution_kind: "delivery", execution_eligibility: ["delivery"], entrypoint: "task", work_type: "new", storage_mode: "tracked_sanitized", client: "codex", agent: "agent", agent_name: "agent", provider: "mixed", model: "mixed", reasoning_effort: null, client_thread_id: "multi", client_turn_id: "multi", conversation_id: "CONV-MULTI", execution_id: "EXEC-MULTI", task_id: "TASK-MULTI", spec_id: null, prd_id: null, change_id: null, parent_run_id: null, continuation_of_run_id: null, retry_of_run_id: null, agent_invocation_id: "AINV-MULTI", root_agent_invocation_id: "AINV-MULTI", parent_agent_invocation_id: null, invocation_kind: "orchestrator", delegation_depth: 0 };
-    const usage = (sequence: number, provider: string, model: string, tokens: number, brl: number) => ({ schema_version: 2, event_id: `RUN-MULTI:${sequence}`, run_id: "RUN-MULTI", sequence, occurred_at: "2026-08-04T12:00:01.000Z", type: "usage.recorded", phase: "execution", activity_kind: "model_usage", classification_source: "explicit", tokens: { input: tokens, cached_input: 0, output: 0, reasoning: 0, total: tokens, source: "provider_reported" }, cost: { usd: brl / 5, brl, fx_rate: 5 }, provider, model, source_segment_key: `${provider}-${model}`, model_call_id: `MCALL-${sequence}`, runtime: { reasoning_effort: null, service_tier: null }, supersedes_event_id: null, source_started_at: "2026-08-04T12:00:00.000Z", source_finished_at: "2026-08-04T12:01:00.000Z", duration_ms: null, duration_provenance: null });
-    const finished = { schema_version: 2, event_id: "RUN-MULTI:5", run_id: "RUN-MULTI", sequence: 5, occurred_at: "2026-08-04T12:01:00.000Z", type: "run.finished", phase: "execution", status: "completed", duration_ms: 60_000, duration_provenance: "observed" };
-    const mixedNullSegment = {
-      ...usage(4, "openai", "gpt-a", 0, 0),
-      event_id: "RUN-MULTI:4",
-      provider: null,
-      model: null,
-      source_segment_key: "mixed-null",
-      model_call_id: "MCALL-MIXED-NULL",
-    };
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-MULTI.jsonl"), `${[started, usage(2, "openai", "gpt-a", 10, 5), usage(3, "anthropic", "claude-b", 20, 10), mixedNullSegment, finished].map((row) => JSON.stringify(row)).join("\n")}\n`);
-    const unavailableStarted = {
-      ...started,
-      event_id: "RUN-UNAVAILABLE:1",
-      run_id: "RUN-UNAVAILABLE",
-      occurred_at: "2026-08-04T14:00:00.000Z",
-      client_turn_id: "unavailable",
-      conversation_id: "CONV-UNAVAILABLE",
-      execution_id: "EXEC-UNAVAILABLE",
-      task_id: "TASK-UNAVAILABLE",
-      agent_invocation_id: "AINV-UNAVAILABLE",
-      root_agent_invocation_id: "AINV-UNAVAILABLE",
-      provider: "unavailable",
-      model: "unavailable",
-    };
-    const unavailableFinished = {
-      ...finished,
-      event_id: "RUN-UNAVAILABLE:2",
-      run_id: "RUN-UNAVAILABLE",
-      sequence: 3,
-      occurred_at: "2026-08-04T14:01:00.000Z",
-    };
-    const unavailableUsage = {
-      ...usage(2, "openai", "gpt-a", 0, 0),
-      event_id: "RUN-UNAVAILABLE:usage",
-      run_id: "RUN-UNAVAILABLE",
-      sequence: 2,
-      occurred_at: "2026-08-04T14:00:01.000Z",
-      provider: null,
-      model: null,
-      source_started_at: "2026-08-04T14:00:00.000Z",
-      source_finished_at: "2026-08-04T14:01:00.000Z",
-      source_segment_key: "unknown-segment",
-      model_call_id: "MCALL-UNAVAILABLE",
-    };
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNAVAILABLE.jsonl"),
-      `${[unavailableStarted, unavailableUsage, unavailableFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
-    );
-    // It is a canonical activity but not an Agent Invocation. Cost Monitor
-    // must not blend this population into its token/cost/session rate.
-    const { agent_invocation_id: _invocation, root_agent_invocation_id: _rootInvocation, parent_agent_invocation_id: _parentInvocation, ...unassistedBase } = started;
-    const unassistedStarted = {
-      ...unassistedBase,
-      event_id: "RUN-UNASSISTED:1",
-      run_id: "RUN-UNASSISTED",
-      occurred_at: "2026-08-04T16:00:00.000Z",
-      client_turn_id: "unassisted",
-      conversation_id: "CONV-UNASSISTED",
-      execution_id: "EXEC-MULTI",
-      task_id: "TASK-MULTI",
+    const 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 unassistedUsage = {
-      ...usage(2, "openai", "gpt-a", 1_000, 500),
-      event_id: "RUN-UNASSISTED:2",
-      run_id: "RUN-UNASSISTED",
-      occurred_at: "2026-08-04T16:00:01.000Z",
-      source_started_at: "2026-08-04T16:00:00.000Z",
-      source_finished_at: "2026-08-04T16:01:00.000Z",
-      source_segment_key: "unassisted-segment",
+    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(root, ".agents", "records", "runs", "2026", "08", "RUN-UNASSISTED.jsonl"),
-      `${[unassistedStarted, unassistedUsage, { ...finished, event_id: "RUN-UNASSISTED:3", run_id: "RUN-UNASSISTED", sequence: 3 }].map((row) => JSON.stringify(row)).join("\n")}\n`,
+      join(assignmentsRoot, "HDA-FIXTURE.json"),
+      JSON.stringify({
+        ...unsigned,
+        manifest_hash: createHash("sha256").update(JSON.stringify(unsigned)).digest("hex"),
+      }),
     );
     await rebuildSqliteReadModel(root);
-    const aggregateDatabase = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
-      readOnly: true,
-    });
-    try {
-      const aggregates = aggregateDatabase.prepare(`SELECT
-        json_extract(payload_json, '$.dimension') AS dimension,
-        json_extract(payload_json, '$.key') AS key,
-        json_extract(payload_json, '$.schema_version') AS schema_version,
-        json_extract(payload_json, '$.total_cost_brl') AS total_cost_brl
-        FROM zaip_aios_activities
-        WHERE payload_type = 'cost_dimension_aggregate_v1'`).all();
-      expect(aggregates).toEqual(expect.arrayContaining([
-        expect.objectContaining({ dimension: "provider", key: "openai", schema_version: 1, total_cost_brl: 505 }),
-        expect.objectContaining({ dimension: "model", key: "gpt-a", schema_version: 1, total_cost_brl: 505 }),
-      ]));
-      expect(aggregates.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
-    } finally {
-      aggregateDatabase.close();
-    }
     const filesystem = new SqliteReadModelFileSystem(root);
-    expect(filesystem.viewPage("cost_monitor_daily", { from: "2026-08-04", to: "2026-08-04" }).rows[0]).toMatchObject({ total_tokens: 1_030, total_cost_brl: 515 });
-    // The public overview view backs /api/v2/sqlite-views. It must not leak
-    // Cost Monitor retains all measurable financial activities, including
-    // historical/unassisted telemetry without an Agent Invocation id.
-    const publicOverview = filesystem.viewPage("cost_monitor_overview_view", {});
-    expect(publicOverview.rows).toHaveLength(3);
-    expect(publicOverview.rows).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ period_kind: "day", total_run_count: 3, invocation_count: 3, total_tokens: 1_030, total_cost_brl: 515 }),
-        expect.objectContaining({ period_kind: "month", total_run_count: 3, invocation_count: 3, total_tokens: 1_030, total_cost_brl: 515 }),
-        expect.objectContaining({ period_kind: "year", total_run_count: 3, invocation_count: 3, total_tokens: 1_030, total_cost_brl: 515 }),
-      ]),
-    );
-    const allAgentGroups = filesystem.viewPage("cost_monitor_zaip_agents", { limit: 20, offset: 0 });
-    const allCostTotals = publicOverview.rows.find((row) => row.period_kind === "day");
-    if (allCostTotals === undefined) throw new Error("Expected the daily Cost Monitor overview");
-    expect(allAgentGroups.rows.reduce((total, row) => total + Number(row.invocation_count ?? 0), 0)).toBe(allCostTotals.total_run_count);
-    expect(allAgentGroups.rows.reduce((total, row) => total + Number(row.total_tokens ?? 0), 0)).toBe(allCostTotals?.total_tokens);
-    expect(allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_brl ?? 0), 0)).toBe(allCostTotals?.total_cost_brl);
-    expect(allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_usd ?? 0), 0)).toBe(allCostTotals.total_cost_usd);
-    // Shared Cost Tempo is factual at the activity grain. It remains available
-    // in the agent-table total even where a multi-dimension invocation cannot
-    // be assigned to an individual Agent row.
-    expect(allCostTotals.cost_monitor_total_duration).toBe(120_000);
-    expect(allAgentGroups.totals).toMatchObject({ invocation_count: allCostTotals.total_run_count, total_duration: 120_000, total_tokens: allCostTotals.total_tokens, total_cost_usd: allCostTotals.total_cost_usd, total_cost_brl: allCostTotals.total_cost_brl });
-    for (const [providers, models] of [[ ["openai"], ["gpt-a"] ], [["anthropic"], ["claude-b"] ]] as const) {
-      const rows = filesystem.invocationCostRows({ from: null, to: null, providers, models });
-      expect(rows).toHaveLength(1);
-      // Membership is segment-based; once the invocation matches, its
-      // canonical invocation totals remain intact rather than being split.
-      expect(rows[0]).toMatchObject({ total_tokens: 30, cost_brl: 15 });
-      expect([...filesystem.executionDurationByDay({ from: null, to: null, providers, models }).values()]).toEqual([60_000]);
-      expect([...filesystem.canonicalRunCountByDay({ from: null, to: null, providers, models }).values()]).toEqual([1]);
-      for (const view of ["cost_monitor_daily", "cost_monitor_monthly", "cost_monitor_annual"] as const) {
-        const page = filesystem.viewPage(view, { provider: providers[0], model: models[0], limit: 20, offset: 0 });
-        expect(page.rows[0]).toMatchObject({ total_run_count: 1, total_tokens: 30, total_cost_brl: 15 });
-      }
-      const agents = filesystem.viewPage("cost_monitor_zaip_agents", { provider: providers[0], model: models[0], query: "agent" });
-      const financialRows = filesystem.costMonitorFinancialActivityRows({ from: null, to: null, providers, models });
-      const financialTotals = financialRows.reduce<{ invocation_count: number; total_tokens: number; total_cost_brl: number }>((total, row) => ({
-        invocation_count: total.invocation_count + 1,
-        total_tokens: total.total_tokens + Number(row.total_tokens ?? 0),
-        total_cost_brl: total.total_cost_brl + Number(row.cost_brl ?? 0),
-      }), { invocation_count: 0, total_tokens: 0, total_cost_brl: 0 });
-      expect(agents.rows[0]).toMatchObject({ key: "agent", persona: "ana", job: "quality_engineer", task_count: 1, ...financialTotals });
-      expect(agents.totals).toMatchObject(financialTotals);
-    }
-    const crossed = { from: null, to: null, providers: ["openai"], models: ["claude-b"] };
-    expect(filesystem.invocationCostRows(crossed)).toHaveLength(0);
-    expect([...filesystem.executionDurationByDay(crossed).values()]).toEqual([]);
-    expect([...filesystem.canonicalRunCountByDay(crossed).values()]).toEqual([]);
-    expect(filesystem.viewPage("cost_monitor_agent_invocations", { provider: "openai", model: "claude-b" }).total_count).toBe(0);
-    expect(filesystem.viewPage("cost_monitor_zaip_agents", { provider: "openai", model: "claude-b" }).total_count).toBe(0);
-    for (const view of ["cost_monitor_daily", "cost_monitor_monthly", "cost_monitor_annual"] as const) {
-      // Lifecycle buckets can remain present independently, but the crossed
-      // pair must contribute no invocation financial or Run facts.
-      const row = filesystem.viewPage(view, { provider: "openai", model: "claude-b" }).rows[0];
-      expect(row).toMatchObject({ total_run_count: 0, total_duration: null, total_tokens: null, total_cost_brl: null });
-    }
-    for (const view of ["cost_monitor_daily", "cost_monitor_monthly", "cost_monitor_annual"] as const) {
-      const originFiltered = filesystem.viewPage(view, { origin: "task" });
-      expect(originFiltered.rows[0]).toMatchObject({ prd_count: null, spec_count: null, task_count: null, validation_count: null, evidence_count: null });
-      expect(filesystem.viewPage(view, { workType: "new" }).total_count).toBe(0);
-    }
-    expect(filesystem.viewPage("cost_monitor_zaip_agents", { priority: "high" })).toMatchObject({ total_count: 0, rows: [] });
-    const providerGroups = filesystem.viewPage("cost_monitor_providers", { limit: 20, offset: 0 });
-    expect(providerGroups.rows).toEqual(expect.arrayContaining([
-      expect.objectContaining({ key: "openai", total_tokens: 1_010, total_cost_brl: 505 }),
-      expect.objectContaining({ key: "anthropic", total_tokens: 20, total_cost_brl: 10 }),
-    ]));
-    expect(providerGroups.rows.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
-    expect(filesystem.viewPage("cost_monitor_providers", { provider: "openai", model: "gpt-a" }).rows.find((row) => row.key === "openai")).toMatchObject({ total_tokens: 10, total_cost_brl: 5 });
-    expect(filesystem.viewPage("cost_monitor_providers", { provider: "openai", model: "claude-b" })).toMatchObject({ total_count: 0, rows: [] });
-    // A source segment can prove its financial facts, but an invocation with
-    // multiple observed providers cannot prove a provider-specific elapsed
-    // time. It must not manufacture a "mixed" bucket for that remainder.
-    const queriedProviderRows = filesystem.viewPage("cost_monitor_providers", { query: "openai" }).rows;
-    expect(queriedProviderRows).toEqual([
-      expect.objectContaining({ key: "openai", total_tokens: 10, total_cost_brl: 5 }),
-    ]);
-    const modelGroups = filesystem.viewPage("cost_monitor_models", { limit: 20, offset: 0 });
-    expect(modelGroups.rows).toEqual(expect.arrayContaining([
-      expect.objectContaining({ key: "gpt-a", total_tokens: 1_010, total_cost_brl: 505 }),
-      expect.objectContaining({ key: "claude-b", total_tokens: 20, total_cost_brl: 10 }),
-    ]));
-    // First-fold transport is aggregate-only, but its overview chart must
-    // retain the segment-backed model rows instead of falling back to the
-    // empty availability metadata.
-    expect(filesystem.costMonitorSummaryAggregate({ from: null, to: null }).model_groups).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ key: "gpt-a", total_tokens: 1_010, estimated_brl: 505 }),
-        expect.objectContaining({ key: "claude-b", total_tokens: 20, estimated_brl: 10 }),
-      ]),
-    );
-    expect(modelGroups.rows.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
-    const modelTotals = modelGroups.rows.reduce<{ invocations: number; tasks: number; duration: number; tokens: number; brl: number }>(
-      (total, row) => ({
-        invocations: total.invocations + Number(row.invocation_count ?? 0),
-        tasks: total.tasks + Number(row.task_count ?? 0),
-        duration: total.duration + Number(row.total_duration ?? 0),
-        tokens: total.tokens + Number(row.total_tokens ?? 0),
-        brl: total.brl + Number(row.total_cost_brl ?? 0),
-      }),
-      { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
-    );
-    expect(modelTotals).toEqual({ invocations: 2, tasks: 3, duration: 60_000, tokens: 1030, brl: 515 });
-    expect(filesystem.viewPage("cost_monitor_models", { query: "gpt-a" }).rows).toHaveLength(1);
-    expect(filesystem.viewPage("cost_monitor_models", { provider: "openai", model: "gpt-a" }).rows[0]).toMatchObject({ key: "gpt-a", total_tokens: 1010, total_cost_brl: 505 });
-    expect(filesystem.viewPage("cost_monitor_models", { provider: "openai", model: "claude-b" })).toMatchObject({ total_count: 0, rows: [] });
-    expect(filesystem.viewPage("cost_monitor_models", { priority: "high" })).toMatchObject({ total_count: 0, rows: [] });
-    const unavailable = { from: null, to: null, providers: ["unavailable"], models: ["unavailable"] };
-    const unavailableRows = filesystem.invocationCostRows(unavailable);
-    expect(unavailableRows).toHaveLength(1);
-    // Observed zero telemetry stays zero, while the missing provider/model
-    // attribute selects this segment rather than a literal sentinel value.
-    expect(unavailableRows[0]).toMatchObject({ total_tokens: 0, cost_brl: 0 });
-    // Execution-duration is an Operations compatibility aggregate and still
-    // includes the unassisted canonical Run. Cost Monitor retains its
-    // measurable financial activity as an unavailable historical fact.
-    expect([...filesystem.executionDurationByDay(unavailable).values()]).toEqual([60_000]);
-    expect([...filesystem.canonicalRunCountByDay(unavailable).values()]).toEqual([2]);
-    const unavailableInvocation = filesystem.viewPage("cost_monitor_agent_invocations", {
-      provider: "unavailable",
-      model: "unavailable",
-    });
-    expect(unavailableInvocation).toMatchObject({ total_count: 1 });
-    expect(unavailableInvocation.rows[0]).toMatchObject({ input_tokens: 0 });
-    for (const view of ["cost_monitor_daily", "cost_monitor_monthly", "cost_monitor_annual"] as const) {
-      const row = filesystem.viewPage(view, { provider: "unavailable", model: "unavailable" }).rows[0];
-      expect(row).toMatchObject({ total_run_count: 2, total_tokens: 1_000, total_cost_brl: 500 });
-    }
-
-    filesystem.close();
-    const sameModelStarted = { ...started, event_id: "RUN-SAME-MODEL:1", run_id: "RUN-SAME-MODEL", occurred_at: "2026-08-05T12:00:00.000Z", client_turn_id: "same-model", conversation_id: "CONV-SAME-MODEL", execution_id: "EXEC-SAME-MODEL", task_id: "TASK-SAME-MODEL", agent_invocation_id: "AINV-SAME-MODEL", root_agent_invocation_id: "AINV-SAME-MODEL", provider: "mixed", model: "gpt-a" };
-    const sameModelUsage = (sequence: number, provider: string, tokens: number, brl: number) => ({ ...usage(sequence, provider, "gpt-a", tokens, brl), event_id: `RUN-SAME-MODEL:${sequence}`, run_id: "RUN-SAME-MODEL", occurred_at: "2026-08-05T12:00:01.000Z", source_started_at: "2026-08-05T12:00:00.000Z", source_finished_at: "2026-08-05T12:01:00.000Z" });
-    const sameModelFinished = { ...finished, event_id: "RUN-SAME-MODEL:4", run_id: "RUN-SAME-MODEL", sequence: 4, occurred_at: "2026-08-05T12:01:00.000Z" };
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-SAME-MODEL.jsonl"), `${[sameModelStarted, sameModelUsage(2, "openai", 3, 1.5), sameModelUsage(3, "anthropic", 4, 2), sameModelFinished].map((row) => JSON.stringify(row)).join("\n")}\n`);
-    const durationRun = (id: string, day: string, duration: number | null, provenance: "reconciled" | "estimated") => {
-      const start = { ...sameModelStarted, event_id: `${id}:1`, run_id: id, occurred_at: `${day}T12:00:00.000Z`, client_turn_id: id, conversation_id: `CONV-${id}`, execution_id: `EXEC-${id}`, task_id: `TASK-${id}`, agent_invocation_id: `AINV-${id}`, root_agent_invocation_id: `AINV-${id}` };
-      const measured = { ...usage(2, "openai", "gpt-a", provenance === "estimated" ? 4_000_000 : 9, provenance === "estimated" ? 0 : 4.5), event_id: `${id}:2`, run_id: id, occurred_at: `${day}T12:00:01.000Z`, source_started_at: `${day}T12:00:00.000Z`, source_finished_at: `${day}T12:01:00.000Z`, ...(duration === null ? {} : { duration_ms: duration, duration_provenance: provenance }) };
-      const end = { ...finished, event_id: `${id}:3`, run_id: id, sequence: 3, occurred_at: `${day}T12:01:00.000Z`, ...(provenance === "estimated" ? { duration_ms: null, duration_provenance: "unavailable" } : {}) };
-      return [start, measured, end];
-    };
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-RECONCILED-MODEL.jsonl"), `${durationRun("RUN-RECONCILED-MODEL", "2026-08-06", 45_000, "reconciled").map((row) => JSON.stringify(row)).join("\n")}\n`);
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-ESTIMATED-MODEL.jsonl"), `${durationRun("RUN-ESTIMATED-MODEL", "2026-08-07", null, "estimated").map((row) => JSON.stringify(row)).join("\n")}\n`);
-    const sharedTaskRun = (id: string, model: string, tokens: number, brl: number) => [
-      { ...sameModelStarted, event_id: `${id}:1`, run_id: id, occurred_at: "2026-08-08T12:00:00.000Z", client_turn_id: id, conversation_id: `CONV-${id}`, execution_id: `EXEC-${id}`, task_id: "TASK-CROSS-MODEL", agent_invocation_id: `AINV-${id}`, root_agent_invocation_id: `AINV-${id}`, provider: "openai", model },
-      { ...usage(2, "openai", model, tokens, brl), event_id: `${id}:2`, run_id: id, occurred_at: "2026-08-08T12:00:01.000Z", source_started_at: "2026-08-08T12:00:00.000Z", source_finished_at: "2026-08-08T12:01:00.000Z" },
-      { ...finished, event_id: `${id}:3`, run_id: id, sequence: 3, occurred_at: "2026-08-08T12:01:00.000Z" },
-    ];
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-TASK-GPT.jsonl"), `${sharedTaskRun("RUN-TASK-GPT", "gpt-a", 5, 2.5).map((row) => JSON.stringify(row)).join("\n")}\n`);
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-TASK-CLAUDE.jsonl"), `${sharedTaskRun("RUN-TASK-CLAUDE", "claude-b", 6, 3).map((row) => JSON.stringify(row)).join("\n")}\n`);
-    const subrunStarted = { ...sameModelStarted, event_id: "RUN-PROVIDER-SUBRUN:1", run_id: "RUN-PROVIDER-SUBRUN", occurred_at: "2026-08-09T12:00:00.000Z", client_turn_id: "provider-subrun", conversation_id: "CONV-PROVIDER-SUBRUN", execution_id: "EXEC-PROVIDER-SUBRUN", task_id: "TASK-PROVIDER-SUBRUN", agent_invocation_id: "AINV-PROVIDER-SUBRUN", root_agent_invocation_id: "AINV-SAME-MODEL", parent_agent_invocation_id: "AINV-SAME-MODEL", parent_run_id: "RUN-SAME-MODEL", run_role: "subagent", invocation_kind: "delegated", delegation_depth: 1, provider: "openai", model: "gpt-a" };
-    const subrunUsage = { ...usage(2, "openai", "gpt-a", 8, 4), event_id: "RUN-PROVIDER-SUBRUN:2", run_id: "RUN-PROVIDER-SUBRUN", occurred_at: "2026-08-09T12:00:01.000Z", source_started_at: "2026-08-09T12:00:00.000Z", source_finished_at: "2026-08-09T12:00:30.000Z" };
-    const subrunFinished = { ...finished, event_id: "RUN-PROVIDER-SUBRUN:3", run_id: "RUN-PROVIDER-SUBRUN", sequence: 3, occurred_at: "2026-08-09T12:00:30.000Z", duration_ms: 30_000, duration_provenance: "observed" };
-    await writeFile(join(root, ".agents", "records", "runs", "2026", "08", "RUN-PROVIDER-SUBRUN.jsonl"), `${[subrunStarted, subrunUsage, subrunFinished].map((row) => JSON.stringify(row)).join("\n")}\n`);
-    await rebuildSqliteReadModel(root);
-    const sameModelFs = new SqliteReadModelFileSystem(root);
-    const modelRow = (filter: Record<string, string>) => sameModelFs.viewPage("cost_monitor_models", { from: "2026-08-05", to: "2026-08-05", ...filter }).rows.find((row) => row.key === "gpt-a");
-    expect(modelRow({ provider: "openai", model: "gpt-a" })).toMatchObject({ invocation_count: 1, task_count: 1, total_duration: 60_000, total_tokens: 3, total_cost_brl: 1.5 });
-    expect(modelRow({ provider: "anthropic", model: "gpt-a" })).toMatchObject({ invocation_count: 1, task_count: 1, total_duration: 60_000, total_tokens: 4, total_cost_brl: 2 });
-    expect(modelRow({})).toMatchObject({ invocation_count: 1, task_count: 1, total_duration: 60_000, total_tokens: 7, total_cost_brl: 3.5 });
-    expect(sameModelFs.viewPage("cost_monitor_models", { from: "2026-08-05", to: "2026-08-05", provider: "openai", model: "claude-b" })).toMatchObject({ total_count: 0, rows: [] });
-    for (const day of ["2026-08-06", "2026-08-07"]) {
-      const effective = sameModelFs.invocationCostRows({ from: day, to: day }).reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0);
-      const modelDuration = sameModelFs.viewPage("cost_monitor_models", { from: day, to: day }).rows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0);
-      expect(modelDuration).toBe(effective);
-    }
-    for (const day of ["2026-08-06", "2026-08-07"]) {
-      const population = sameModelFs.invocationCostRows({ from: day, to: day });
-      const providerRows = sameModelFs.viewPage("cost_monitor_providers", { from: day, to: day }).rows;
-      const providerTotals = providerRows.reduce<{ invocations: number; tasks: number; duration: number; tokens: number; brl: number }>(
-        (total, row) => ({
-          invocations: total.invocations + Number(row.invocation_count ?? 0),
-          tasks: total.tasks + Number(row.task_count ?? 0),
-          duration: total.duration + Number(row.total_duration ?? 0),
-          tokens: total.tokens + Number(row.total_tokens ?? 0),
-          brl: total.brl + Number(row.total_cost_brl ?? 0),
+    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" }),
+          ]),
         }),
-        { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
-      );
-      expect(providerTotals).toEqual({
-        invocations: population.length,
-        tasks: new Set(population.map((row) => row.task_id).filter((id): id is string => typeof id === "string")).size,
-        duration: population.reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0),
-        tokens: population.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
-        brl: population.reduce((sum, row) => sum + Number(row.cost_brl ?? 0), 0),
+      ]);
+      // 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();
     }
-    const sharedTaskRows = sameModelFs.viewPage("cost_monitor_models", { from: "2026-08-08", to: "2026-08-08" }).rows;
-    expect(sharedTaskRows).toEqual(expect.arrayContaining([
-      expect.objectContaining({ key: "gpt-a", invocation_count: 1, task_count: 1, total_duration: 30_000, total_tokens: 5, total_cost_brl: 2.5 }),
-      expect.objectContaining({ key: "claude-b", invocation_count: 1, task_count: 1, total_duration: 30_000, total_tokens: 6, total_cost_brl: 3 }),
-    ]));
-    expect(sharedTaskRows.map((row) => row.key)).not.toContain("mixed");
-    expect(sharedTaskRows.reduce((sum, row) => sum + Number(row.task_count ?? 0), 0)).toBe(2);
-    const subrunPopulation = sameModelFs.invocationCostRows({ from: "2026-08-09", to: "2026-08-09", providers: ["openai"], models: ["gpt-a"] });
-    const subrunProviderRows = sameModelFs.viewPage("cost_monitor_providers", { from: "2026-08-09", to: "2026-08-09", provider: "openai", model: "gpt-a" }).rows;
-    const subrunProviderTotals = subrunProviderRows.reduce<{ invocations: number; tasks: number; duration: number; tokens: number; brl: number }>(
-      (total, row) => ({ invocations: total.invocations + Number(row.invocation_count ?? 0), tasks: total.tasks + Number(row.task_count ?? 0), duration: total.duration + Number(row.total_duration ?? 0), tokens: total.tokens + Number(row.total_tokens ?? 0), brl: total.brl + Number(row.total_cost_brl ?? 0) }),
-      { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
-    );
-    expect(subrunProviderTotals).toEqual({ invocations: subrunPopulation.length, tasks: new Set(subrunPopulation.map((row) => row.task_id).filter((id): id is string => typeof id === "string")).size, duration: subrunPopulation.reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0), tokens: subrunPopulation.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0), brl: subrunPopulation.reduce((sum, row) => sum + Number(row.cost_brl ?? 0), 0) });
-    expect(sameModelFs.viewPage("cost_monitor_providers", { from: "2026-08-09", to: "2026-08-09", provider: "openai", model: "claude-b" })).toMatchObject({ total_count: 0, rows: [] });
-    sameModelFs.close();
   });
 
   it("prefers the canonical started-to-finished interval over a token estimate", async () => {
@@ -1007,7 +1579,7 @@ created_at: 2026-08-10T11:01:00.000Z
     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",
+      "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 = {
@@ -1216,49 +1788,135 @@ created_at: 2026-08-10T11:01:00.000Z
     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 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,
+          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,
+          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}: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",
+          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" },
+      // 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`),
@@ -1310,18 +1968,53 @@ created_at: 2026-08-10T11:01:00.000Z
       `${[historicalStarted, ...historicalRecords.slice(1)].map((record) => JSON.stringify(record)).join("\n")}\n`,
     );
     await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), { readOnly: true });
-    expect(database.prepare("SELECT duration_ms, source_duration_ms, duration_provenance FROM zaip_aios_activities WHERE run_id='RUN-planning'").get()).toEqual({ duration_ms: 4_020_000, source_duration_ms: 6_240_000, duration_provenance: "attributed_token_active" });
-    const daily = database.prepare("SELECT day, total_duration, invocation_count, cost_monitor_invocation_count, cost_monitor_total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day").all();
+    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database
+        .prepare(
+          "SELECT duration_ms, source_duration_ms, duration_provenance FROM zaip_aios_activities WHERE run_id='RUN-planning'",
+        )
+        .get(),
+    ).toEqual({
+      duration_ms: 4_020_000,
+      source_duration_ms: 6_240_000,
+      duration_provenance: "attributed_token_active",
+    });
+    const daily = database
+      .prepare(
+        "SELECT day, total_duration, invocation_count, cost_monitor_invocation_count, cost_monitor_total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day",
+      )
+      .all();
     expect(daily).toEqual([
-      { day: "2026-07-22", total_duration: 2_580_000, invocation_count: 1, cost_monitor_invocation_count: 1, cost_monitor_total_duration: 2_580_000 },
-      { day: "2026-07-23", total_duration: 5_420_000, invocation_count: 4, cost_monitor_invocation_count: 5, cost_monitor_total_duration: 5_420_000 },
+      {
+        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 });
+    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" })
+      factualFilesystem
+        .costMonitorFinancialActivityRows({ from: "2026-07-23", to: "2026-07-23" })
         .some((row) => row.run_id === "RUN-historical-financial"),
     ).toBe(true);
     const compactFinancialRow = factualFilesystem.costMonitorFinancialActivityRows({
@@ -1331,41 +2024,59 @@ created_at: 2026-08-10T11:01:00.000Z
     expect(compactFinancialRow).not.toHaveProperty("payload_json");
     expect(compactFinancialRow).toHaveProperty("total_tokens");
     expect(
-      factualFilesystem.costMonitorFinancialActivityRows({ from: "2026-07-24", to: "2026-07-24" })
+      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"),
+      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"),
+      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),
+      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),
+      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) {
+    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),
+        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.
@@ -1376,20 +2087,40 @@ created_at: 2026-08-10T11:01:00.000Z
         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);
+      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),
+        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);
+    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 });
+    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();
   });
 
@@ -1398,42 +2129,231 @@ created_at: 2026-08-10T11:01:00.000Z
     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", "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");
+    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");
+      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" },
+      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");
+    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 }));
+    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();
   });
 
@@ -1448,18 +2368,28 @@ created_at: 2026-08-10T11:01:00.000Z
       { recursive: true },
     );
     await mkdir(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "validations"),
+      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",
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
       "utf8",
     );
     await writeFile(
       join(root, ".agents", "config", "framework.lock.yaml"),
-      "lock_version: 1\nframework:\n  version: 1.0.8\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+      "lock_version: 1\nframework:\n  version: 1.3.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
       "utf8",
     );
     const run = (
@@ -1553,9 +2483,18 @@ created_at: 2026-08-10T11:01:00.000Z
       },
     ];
     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")],
+      [
+        "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`),
@@ -1564,16 +2503,42 @@ created_at: 2026-08-10T11:01:00.000Z
       );
     }
     await writeFile(
-      join(root, ".agents", "records", "changes", "2026", "08", "CHG-ART", "artifacts", "evidence", "EVD-1.md"),
+      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"),
+      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)
+    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`,
@@ -1624,6 +2589,7 @@ created_at: 2026-08-10T11:01:00.000Z
       }),
     );
     const allTime = filesystem.firstFoldAllTime();
+    expectPersistedFirstFoldCaches(root, allTime, filesystem.firstFoldBoardAllTime());
     expect(allTime.aggregate).toMatchObject({
       start_day: "2026-08-01",
       end_day: "2026-08-03",
@@ -1710,7 +2676,11 @@ created_at: 2026-08-10T11:01:00.000Z
       { 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 } };
+      summary: {
+        run_count: number;
+        task_count: number;
+        overview_metrics: { tokens: number | null; duration_ms: number | null };
+      };
     };
     expect(nextMonth.summary).toMatchObject({
       run_count: 0,
@@ -1808,9 +2778,21 @@ created_at: 2026-08-10T11:01:00.000Z
       ]);
     }
     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 }],
+      [
+        "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 }),
@@ -1828,7 +2810,10 @@ created_at: 2026-08-10T11:01:00.000Z
     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).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),
@@ -1841,9 +2826,17 @@ created_at: 2026-08-10T11:01:00.000Z
     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",
+      "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])
@@ -1883,7 +2876,14 @@ created_at: 2026-08-10T11:01:00.000Z
         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({
+    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,
@@ -1894,24 +2894,75 @@ created_at: 2026-08-10T11:01:00.000Z
     // 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({
+    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 })],
+      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({
+    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 })],
+      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 });
+    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(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.viewPage("cost_monitor_tasks", { workType: "new", limit: 1 })).toMatchObject({
+      total_count: 0,
+      rows: [],
+    });
     expect(filesystem.firstFoldAllTime()).toBe(allTime);
     filesystem.close();
 
@@ -1925,26 +2976,61 @@ created_at: 2026-08-10T11:01:00.000Z
     );
     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`,
+      `${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`,
+      `${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({
+    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 })],
+      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: [] });
+    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
@@ -1953,7 +3039,9 @@ created_at: 2026-08-10T11:01:00.000Z
       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`,
+        `${run(id, "2026-08-04", `TASK-PAGE-${index}`, 1_000)
+          .map((record) => JSON.stringify(record))
+          .join("\n")}\n`,
         "utf8",
       );
     }