@zaip-ai/cli 1.3.0 → 1.3.1

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

@@ -1,19 +1,19 @@
+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 { 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",
@@ -32,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();
@@ -63,6 +62,31 @@ 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);
@@ -175,7 +199,7 @@ describe("SQLite dashboard read model", () => {
     }
   });
 
-  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 });
@@ -189,15 +213,15 @@ describe("SQLite dashboard read model", () => {
     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"),
+      (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'",
+        "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();
@@ -345,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);
@@ -618,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: {
@@ -981,13 +1006,41 @@ 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) => [
+    const run = (id: string, taskId: string, tokens: number, changeId: string | null = null) => [
       {
         schema_version: 2,
         event_id: `${id}:1`,
@@ -1008,6 +1061,14 @@ created_at: 2026-08-10T11:01:00.000Z
         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,
@@ -1018,7 +1079,7 @@ created_at: 2026-08-10T11:01:00.000Z
         task_id: taskId,
         spec_id: null,
         prd_id: null,
-        change_id: null,
+        change_id: changeId,
         parent_run_id: null,
         continuation_of_run_id: null,
         retry_of_run_id: null,
@@ -1073,7 +1134,7 @@ created_at: 2026-08-10T11:01:00.000Z
     ];
     await writeFile(
       join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL.jsonl"),
-      `${run("RUN-CANONICAL", "TASK-CANONICAL", 7)
+      `${run("RUN-CANONICAL", "TASK-CANONICAL", 7, "CHG-CANONICAL")
         .map((row) => JSON.stringify(row))
         .join("\n")}\n`,
     );
@@ -1083,6 +1144,36 @@ created_at: 2026-08-10T11:01:00.000Z
         .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"), {
@@ -1092,7 +1183,7 @@ created_at: 2026-08-10T11:01:00.000Z
       snapshot
         .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
         .get(),
-    ).toEqual({ value: "60" });
+    ).toEqual({ value: "70" });
     snapshot.close();
     const filesystem = new SqliteReadModelFileSystem(root);
     try {
@@ -1119,881 +1210,366 @@ created_at: 2026-08-10T11:01:00.000Z
           total_cost_brl: 0.55,
         }),
       );
-    } finally {
-      filesystem.close();
-    }
-  });
-
-  it("keeps a multi-provider and multi-model Run visible to both filtered financial and duration facts", async () => {
-    const root = await createSqliteTestRoot();
-    roots.push(root);
-    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
-    await mkdir(join(root, ".agents", "config"), { recursive: true });
-    await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
-    await mkdir(join(root, ".agents", "config", "pricing"), { recursive: true });
-    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
-    await writeFile(
-      join(root, ".agents", "config", "agents", "catalog.yaml"),
-      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
-    );
-    await writeFile(
-      join(root, ".agents", "config", "pricing", "models.json"),
-      JSON.stringify({
-        schema_version: 1,
-        updated_at: "2026-08-04T00:00:00.000Z",
-        source: "fixture",
-        disclaimer: "fixture",
-        models: [
-          {
-            id: "gpt-a",
-            provider: "openai",
-            aliases: [],
-            input_per_million_usd: 2,
-            cached_input_per_million_usd: 0.2,
-            output_per_million_usd: 8,
-            reasoning_per_million_usd: 8,
-            reasoning_billed_separately: false,
-            long_context_threshold_tokens: null,
-            long_context_input_multiplier: 1,
-            long_context_output_multiplier: 1,
-            source_label: "fixture-openai",
-            source_url: "https://example.test/openai",
-            notes: [],
-          },
-          {
-            id: "claude-b",
-            provider: "anthropic",
-            aliases: [],
-            input_per_million_usd: 3,
-            cached_input_per_million_usd: 0.3,
-            output_per_million_usd: 12,
-            reasoning_per_million_usd: null,
-            reasoning_billed_separately: false,
-            long_context_threshold_tokens: null,
-            long_context_input_multiplier: 1,
-            long_context_output_multiplier: 1,
-            source_label: "fixture-anthropic",
-            source_url: "https://example.test/anthropic",
-            notes: [],
-          },
-        ],
-      }),
-    );
-    const started = {
-      schema_version: 2,
-      event_id: "RUN-MULTI:1",
-      run_id: "RUN-MULTI",
-      sequence: 1,
-      occurred_at: "2026-08-04T12:00:00.000Z",
-      type: "run.started",
-      attribution_status: "attributed",
-      phase: "execution",
-      run_role: "orchestrator",
-      run_purpose: "execution",
-      requires_finalizer: false,
-      execution_kind: "delivery",
-      execution_eligibility: ["delivery"],
-      entrypoint: "task",
-      work_type: "new",
-      storage_mode: "tracked_sanitized",
-      client: "codex",
-      agent: "agent",
-      agent_name: "agent",
-      provider: "mixed",
-      model: "mixed",
-      reasoning_effort: null,
-      client_thread_id: "multi",
-      client_turn_id: "multi",
-      conversation_id: "CONV-MULTI",
-      execution_id: "EXEC-MULTI",
-      task_id: "TASK-MULTI",
-      spec_id: null,
-      prd_id: null,
-      change_id: null,
-      parent_run_id: null,
-      continuation_of_run_id: null,
-      retry_of_run_id: null,
-      agent_invocation_id: "AINV-MULTI",
-      root_agent_invocation_id: "AINV-MULTI",
-      parent_agent_invocation_id: null,
-      invocation_kind: "orchestrator",
-      delegation_depth: 0,
-    };
-    const usage = (
-      sequence: number,
-      provider: string,
-      model: string,
-      tokens: number,
-      brl: number,
-    ) => ({
-      schema_version: 2,
-      event_id: `RUN-MULTI:${sequence}`,
-      run_id: "RUN-MULTI",
-      sequence,
-      occurred_at: "2026-08-04T12:00:01.000Z",
-      type: "usage.recorded",
-      phase: "execution",
-      activity_kind: "model_usage",
-      classification_source: "explicit",
-      tokens: {
-        input: tokens,
-        cached_input: 0,
-        output: 0,
-        reasoning: 0,
-        total: tokens,
-        source: "provider_reported",
-      },
-      cost: { usd: brl / 5, brl, fx_rate: 5 },
-      provider,
-      model,
-      source_segment_key: `${provider}-${model}`,
-      model_call_id: `MCALL-${sequence}`,
-      runtime: { reasoning_effort: null, service_tier: null },
-      supersedes_event_id: null,
-      source_started_at: "2026-08-04T12:00:00.000Z",
-      source_finished_at: "2026-08-04T12:01:00.000Z",
-      duration_ms: null,
-      duration_provenance: null,
-    });
-    const finished = {
-      schema_version: 2,
-      event_id: "RUN-MULTI:5",
-      run_id: "RUN-MULTI",
-      sequence: 5,
-      occurred_at: "2026-08-04T12:01:00.000Z",
-      type: "run.finished",
-      phase: "execution",
-      status: "completed",
-      duration_ms: 60_000,
-      duration_provenance: "observed",
-    };
-    const mixedNullSegment = {
-      ...usage(4, "openai", "gpt-a", 0, 0),
-      event_id: "RUN-MULTI:4",
-      provider: null,
-      model: null,
-      source_segment_key: "mixed-null",
-      model_call_id: "MCALL-MIXED-NULL",
-    };
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-MULTI.jsonl"),
-      `${[started, usage(2, "openai", "gpt-a", 10, 5), usage(3, "anthropic", "claude-b", 20, 10), mixedNullSegment, finished].map((row) => JSON.stringify(row)).join("\n")}\n`,
-    );
-    const unavailableStarted = {
-      ...started,
-      event_id: "RUN-UNAVAILABLE:1",
-      run_id: "RUN-UNAVAILABLE",
-      occurred_at: "2026-08-04T14:00:00.000Z",
-      client_turn_id: "unavailable",
-      conversation_id: "CONV-UNAVAILABLE",
-      execution_id: "EXEC-UNAVAILABLE",
-      task_id: "TASK-UNAVAILABLE",
-      agent_invocation_id: "AINV-UNAVAILABLE",
-      root_agent_invocation_id: "AINV-UNAVAILABLE",
-      provider: "unavailable",
-      model: "unavailable",
-    };
-    const unavailableFinished = {
-      ...finished,
-      event_id: "RUN-UNAVAILABLE:2",
-      run_id: "RUN-UNAVAILABLE",
-      sequence: 3,
-      occurred_at: "2026-08-04T14:01:00.000Z",
-    };
-    const unavailableUsage = {
-      ...usage(2, "openai", "gpt-a", 0, 0),
-      event_id: "RUN-UNAVAILABLE:usage",
-      run_id: "RUN-UNAVAILABLE",
-      sequence: 2,
-      occurred_at: "2026-08-04T14:00:01.000Z",
-      provider: null,
-      model: null,
-      source_started_at: "2026-08-04T14:00:00.000Z",
-      source_finished_at: "2026-08-04T14:01:00.000Z",
-      source_segment_key: "unknown-segment",
-      model_call_id: "MCALL-UNAVAILABLE",
-    };
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNAVAILABLE.jsonl"),
-      `${[unavailableStarted, unavailableUsage, unavailableFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
-    );
-    // It is a canonical activity but not an Agent Invocation. Cost Monitor
-    // must not blend this population into its token/cost/session rate.
-    const {
-      agent_invocation_id: _invocation,
-      root_agent_invocation_id: _rootInvocation,
-      parent_agent_invocation_id: _parentInvocation,
-      ...unassistedBase
-    } = started;
-    const unassistedStarted = {
-      ...unassistedBase,
-      event_id: "RUN-UNASSISTED:1",
-      run_id: "RUN-UNASSISTED",
-      occurred_at: "2026-08-04T16:00:00.000Z",
-      client_turn_id: "unassisted",
-      conversation_id: "CONV-UNASSISTED",
-      execution_id: "EXEC-MULTI",
-      task_id: "TASK-MULTI",
-    };
-    const unassistedUsage = {
-      ...usage(2, "openai", "gpt-a", 1_000, 500),
-      event_id: "RUN-UNASSISTED:2",
-      run_id: "RUN-UNASSISTED",
-      occurred_at: "2026-08-04T16:00:01.000Z",
-      source_started_at: "2026-08-04T16:00:00.000Z",
-      source_finished_at: "2026-08-04T16:01:00.000Z",
-      source_segment_key: "unassisted-segment",
-    };
-    await writeFile(
-      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNASSISTED.jsonl"),
-      `${[unassistedStarted, unassistedUsage, { ...finished, event_id: "RUN-UNASSISTED:3", run_id: "RUN-UNASSISTED", sequence: 3 }].map((row) => JSON.stringify(row)).join("\n")}\n`,
-    );
-    await rebuildSqliteReadModel(root);
-    const aggregateDatabase = new DatabaseSync(
-      resolve(root, ".local/dashboard-sqlite/read-model.sqlite"),
-      {
-        readOnly: true,
-      },
-    );
-    try {
-      const aggregates = aggregateDatabase
-        .prepare(`SELECT
-        json_extract(payload_json, '$.dimension') AS dimension,
-        json_extract(payload_json, '$.key') AS key,
-        json_extract(payload_json, '$.schema_version') AS schema_version,
-        json_extract(payload_json, '$.total_cost_brl') AS total_cost_brl
-        FROM zaip_aios_activities
-        WHERE payload_type = 'cost_dimension_aggregate_v1'`)
-        .all();
-      expect(aggregates).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            dimension: "provider",
-            key: "openai",
-            schema_version: 1,
-            total_cost_brl: 505,
-          }),
-          expect.objectContaining({
-            dimension: "model",
-            key: "gpt-a",
-            schema_version: 1,
-            total_cost_brl: 505,
-          }),
-        ]),
-      );
-      expect(aggregates.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
-    } finally {
-      aggregateDatabase.close();
-    }
-    const filesystem = new SqliteReadModelFileSystem(root);
-    expect(
-      filesystem.viewPage("cost_monitor_daily", { from: "2026-08-04", to: "2026-08-04" }).rows[0],
-    ).toMatchObject({ total_tokens: 1_030, total_cost_brl: 515 });
-    // The public overview view backs /api/v2/sqlite-views. It must not leak
-    // Cost Monitor retains all measurable financial activities, including
-    // historical/unassisted telemetry without an Agent Invocation id.
-    const publicOverview = filesystem.viewPage("cost_monitor_overview_view", {});
-    expect(publicOverview.rows).toHaveLength(3);
-    expect(publicOverview.rows).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          period_kind: "day",
-          total_run_count: 3,
-          invocation_count: 3,
-          total_tokens: 1_030,
-          total_cost_brl: 515,
-        }),
-        expect.objectContaining({
-          period_kind: "month",
-          total_run_count: 3,
-          invocation_count: 3,
-          total_tokens: 1_030,
-          total_cost_brl: 515,
-        }),
+      const developers = filesystem.developerCostAggregate({
+        from: null,
+        to: null,
+        accountIds: ["42"],
+      });
+      expect(developers.rows).toEqual([
         expect.objectContaining({
-          period_kind: "year",
-          total_run_count: 3,
-          invocation_count: 3,
-          total_tokens: 1_030,
-          total_cost_brl: 515,
+          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" })],
+            }),
+          ],
         }),
-      ]),
-    );
-    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({
+      ]);
+      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,
-        providers,
-        models,
+        accountIds: ["42"],
       });
-      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),
+      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,
         }),
-        { 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 });
+      ]);
+    } finally {
+      filesystem.close();
     }
+  });
 
-    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",
-    };
+  it("qualifies factual developer deliveries without inventing missing completion or coverage", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const runsRoot = join(root, ".agents", "records", "runs", "2026", "08");
+    const tasksRoot = join(root, ".agents", "records", "tasks", "2026", "08");
+    const assignmentsRoot = join(
+      root,
+      ".agents",
+      "records",
+      "lifecycle",
+      "historical-developer-attribution",
+    );
+    await Promise.all([
+      mkdir(runsRoot, { recursive: true }),
+      mkdir(tasksRoot, { recursive: true }),
+      mkdir(assignmentsRoot, { recursive: true }),
+      mkdir(join(root, ".agents", "config"), { recursive: true }),
+    ]);
     await writeFile(
-      join(root, ".agents", "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`,
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
     );
-    const durationRun = (
+    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,
-      duration: number | null,
-      provenance: "reconciled" | "estimated",
+      tokens: number | null,
     ) => {
-      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,
+      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: 3,
+        sequence: records.length + 1,
         occurred_at: `${day}T12:01:00.000Z`,
-        ...(provenance === "estimated"
-          ? { duration_ms: null, duration_provenance: "unavailable" }
-          : {}),
-      };
-      return [start, measured, end];
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
+      });
+      return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`;
     };
-    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",
+    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,
       },
-    ];
-    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",
+      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-PROVIDER-SUBRUN.jsonl"),
-      `${[subrunStarted, subrunUsage, subrunFinished].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 sameModelFs = new SqliteReadModelFileSystem(root);
-    const modelRow = (filter: Record<string, string>) =>
-      sameModelFs
-        .viewPage("cost_monitor_models", { from: "2026-08-05", to: "2026-08-05", ...filter })
-        .rows.find((row) => row.key === "gpt-a");
-    expect(modelRow({ provider: "openai", model: "gpt-a" })).toMatchObject({
-      invocation_count: 1,
-      task_count: 1,
-      total_duration: 60_000,
-      total_tokens: 3,
-      total_cost_brl: 1.5,
-    });
-    expect(modelRow({ provider: "anthropic", model: "gpt-a" })).toMatchObject({
-      invocation_count: 1,
-      task_count: 1,
-      total_duration: 60_000,
-      total_tokens: 4,
-      total_cost_brl: 2,
-    });
-    expect(modelRow({})).toMatchObject({
-      invocation_count: 1,
-      task_count: 1,
-      total_duration: 60_000,
-      total_tokens: 7,
-      total_cost_brl: 3.5,
-    });
-    expect(
-      sameModelFs.viewPage("cost_monitor_models", {
-        from: "2026-08-05",
-        to: "2026-08-05",
-        provider: "openai",
-        model: "claude-b",
-      }),
-    ).toMatchObject({ total_count: 0, rows: [] });
-    for (const day of ["2026-08-06", "2026-08-07"]) {
-      const effective = sameModelFs
-        .invocationCostRows({ from: day, to: day })
-        .reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0);
-      const modelDuration = sameModelFs
-        .viewPage("cost_monitor_models", { from: day, to: day })
-        .rows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0);
-      expect(modelDuration).toBe(effective);
-    }
-    for (const day of ["2026-08-06", "2026-08-07"]) {
-      const population = sameModelFs.invocationCostRows({ from: day, to: day });
-      const providerRows = sameModelFs.viewPage("cost_monitor_providers", {
-        from: day,
-        to: day,
-      }).rows;
-      const providerTotals = providerRows.reduce<{
-        invocations: number;
-        tasks: number;
-        duration: number;
-        tokens: number;
-        brl: number;
-      }>(
-        (total, row) => ({
-          invocations: total.invocations + Number(row.invocation_count ?? 0),
-          tasks: total.tasks + Number(row.task_count ?? 0),
-          duration: total.duration + Number(row.total_duration ?? 0),
-          tokens: total.tokens + Number(row.total_tokens ?? 0),
-          brl: total.brl + Number(row.total_cost_brl ?? 0),
-        }),
-        { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
-      );
-      expect(providerTotals).toEqual({
-        invocations: population.length,
-        tasks: new Set(
-          population.map((row) => row.task_id).filter((id): id is string => typeof id === "string"),
-        ).size,
-        duration: population.reduce((sum, row) => sum + Number(row.duration_ms ?? 0), 0),
-        tokens: population.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
-        brl: population.reduce((sum, row) => sum + Number(row.cost_brl ?? 0), 0),
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      const all = filesystem.developerCostAggregate({ from: null, to: null });
+      const deliveredBy42 = all.rows.find((row) => row.account_id === "42")!;
+      expect(deliveredBy42).toMatchObject({
+        qualification: "verified",
+        completed_task_count: 1,
+        run_count: 4,
+        token_covered_runs: 3,
+        usd_covered_runs: 3,
+        brl_covered_runs: 3,
       });
-    }
-    const sharedTaskRows = sameModelFs.viewPage("cost_monitor_models", {
-      from: "2026-08-08",
-      to: "2026-08-08",
-    }).rows;
-    expect(sharedTaskRows).toEqual(
-      expect.arrayContaining([
+      expect(deliveredBy42.completed_tasks).toEqual([
         expect.objectContaining({
-          key: "gpt-a",
-          invocation_count: 1,
-          task_count: 1,
-          total_duration: 30_000,
-          total_tokens: 5,
-          total_cost_brl: 2.5,
+          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" }),
+          ]),
         }),
-        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", {
+      ]);
+      // 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",
-        provider: "openai",
-        model: "claude-b",
-      }),
-    ).toMatchObject({ total_count: 0, rows: [] });
-    sameModelFs.close();
+        accountIds: ["42"],
+      }).rows[0]!;
+      expect(unknownDay).toMatchObject({
+        run_count: 3,
+        token_covered_runs: 2,
+        usd_covered_runs: 2,
+        brl_covered_runs: 2,
+      });
+      expect(unknownDay.total_tokens).toBe(9);
+      expect(
+        filesystem.dailyPeriods({ from: "2026-08-09", to: "2026-08-09" })["2026-08-09"],
+      ).toMatchObject({
+        runs: 4,
+        usage: {
+          total_tokens: { known_sum: 11, unknown: 1 },
+          cost: { known_sum: 0.55, unknown: 1 },
+        },
+      });
+    } finally {
+      filesystem.close();
+    }
+    await writeFile(join(assignmentsRoot, "HDA-FIXTURE.json"), "{corrupt");
+    await rebuildSqliteReadModel(root, { forceCanonical: true });
+    const corrupt = new SqliteReadModelFileSystem(root);
+    try {
+      expect(
+        corrupt.developerCostAggregate({ from: null, to: null }).rows.map((row) => row.account_id),
+      ).not.toContain("199126185");
+    } finally {
+      corrupt.close();
+    }
   });
 
   it("prefers the canonical started-to-finished interval over a token estimate", async () => {
@@ -3013,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",