@zaip-ai/cli 2.2.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-keeps-orphan-telemetry-out-kanban-without.test.ts

@@ -0,0 +1,710 @@
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+const roots: string[] = [];
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
+async function createSqliteTestRoot(): Promise<string> {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
+}
+afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await Promise.all(
+    roots
+      .splice(0)
+      .map((root) =>
+        import("node:fs/promises").then(({ rm }) => rm(root, { recursive: true, force: true })),
+      ),
+  );
+});
+describe("SQLite dashboard read model", () => {
+  it("keeps orphan telemetry out of the Kanban without dropping its Cost Monitor fact", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "tasks", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CANONICAL",
+        "artifacts",
+        "tests",
+      ),
+      { recursive: true },
+    );
+    await mkdir(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CANONICAL",
+        "artifacts",
+        "evidence",
+      ),
+      { recursive: true },
+    );
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "records", "tasks", "2026", "08", "TASK-CANONICAL.md"),
+      "---\nid: TASK-CANONICAL\ntitle: Titulo semantico canonico\nstatus: completed\ncompleted_run_id: RUN-CANONICAL\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# Titulo semantico canonico\n",
+    );
+    const run = (id: string, taskId: string, tokens: number, changeId: string | null = null) => [
+      {
+        schema_version: 2,
+        event_id: `${id}:1`,
+        run_id: id,
+        sequence: 1,
+        occurred_at: "2026-08-08T12:00:00.000Z",
+        type: "run.started",
+        attribution_status: "attributed",
+        phase: "execution",
+        run_role: "orchestrator",
+        run_purpose: "execution",
+        requires_finalizer: false,
+        execution_kind: "delivery",
+        execution_eligibility: ["delivery"],
+        entrypoint: "task",
+        work_type: "new",
+        storage_mode: "tracked_sanitized",
+        client: "codex",
+        agent: "agent",
+        agent_name: "agent",
+        developer_identity: {
+          schema_version: 1,
+          provider: "github",
+          account_id: "42",
+          login_snapshot: "dev-fixture",
+          verified_at: "2026-08-08T12:00:00.000Z",
+          attribution_source: "verified_local_account",
+        },
+        provider: "openai",
+        model: "gpt-a",
+        reasoning_effort: null,
+        client_thread_id: id,
+        client_turn_id: id,
+        conversation_id: `CONV-${id}`,
+        execution_id: `EXEC-${id}`,
+        task_id: taskId,
+        spec_id: null,
+        prd_id: null,
+        change_id: changeId,
+        parent_run_id: null,
+        continuation_of_run_id: null,
+        retry_of_run_id: null,
+        agent_invocation_id: `AINV-${id}`,
+        root_agent_invocation_id: `AINV-${id}`,
+        parent_agent_invocation_id: null,
+        invocation_kind: "orchestrator",
+        delegation_depth: 0,
+      },
+      {
+        schema_version: 2,
+        event_id: `${id}:2`,
+        run_id: id,
+        sequence: 2,
+        occurred_at: "2026-08-08T12:00:30.000Z",
+        type: "usage.recorded",
+        phase: "execution",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: tokens,
+          cached_input: 0,
+          output: 0,
+          reasoning: 0,
+          total: tokens,
+          source: "provider_reported",
+        },
+        cost: { usd: tokens / 100, brl: tokens / 20, fx_rate: 5 },
+        provider: "openai",
+        model: "gpt-a",
+        source_segment_key: id,
+        model_call_id: `MCALL-${id}`,
+        runtime: { reasoning_effort: null, service_tier: null },
+        supersedes_event_id: null,
+        source_started_at: "2026-08-08T12:00:00.000Z",
+        source_finished_at: "2026-08-08T12:01:00.000Z",
+        duration_ms: null,
+        duration_provenance: null,
+      },
+      {
+        schema_version: 2,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: 3,
+        occurred_at: "2026-08-08T12:01:00.000Z",
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
+      },
+    ];
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CANONICAL.jsonl"),
+      `${run("RUN-CANONICAL", "TASK-CANONICAL", 7, "CHG-CANONICAL")
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-ORPHAN.jsonl"),
+      `${run("RUN-ORPHAN", "TASK-ORPHAN-REFERENCE", 11)
+        .map((row) => JSON.stringify(row))
+        .join("\n")}\n`,
+    );
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CANONICAL",
+        "artifacts",
+        "tests",
+        "TEST-CANONICAL.md",
+      ),
+      "---\nid: TEST-CANONICAL\nkind: test\ntask_id: TASK-CANONICAL\nchange_id: CHG-CANONICAL\nrun_id: RUN-CANONICAL\nexecuted_at: 2026-08-08T12:00:00.000Z\nstatus: passed\n---\n# Test\n",
+    );
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CANONICAL",
+        "artifacts",
+        "evidence",
+        "EVD-CANONICAL.md",
+      ),
+      "---\nid: EVD-CANONICAL\ntask_id: TASK-CANONICAL\nchange_id: CHG-CANONICAL\nrun_id: RUN-CANONICAL\nobserved_at: 2026-08-08T12:00:00.000Z\nstatus: passed\n---\n# Evidence\n",
+    );
+
+    await rebuildSqliteReadModel(root);
+    const snapshot = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
+      readOnly: true,
+    });
+    try {
+      expect(
+        snapshot
+          .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
+          .get(),
+      ).toEqual({ value: "74" });
+    } finally {
+      snapshot.close();
+    }
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(filesystem.viewPage("operations_work_kanban", { limit: 20 }).rows).toEqual([
+        expect.objectContaining({ id: "TASK-CANONICAL", title: "Titulo semantico canonico" }),
+      ]);
+      // The List export is sourced from this SQLite view, so its known facts
+      // must survive the public entity union rather than be left as blank XLSX
+      // columns by a mapper that only receives identity fields.
+      expect(filesystem.viewPage("operations_work_list", { limit: 20 }).rows).toContainEqual(
+        expect.objectContaining({
+          id: "TASK-CANONICAL",
+          invocation_count: 1,
+          total_duration: 30_000,
+          total_tokens: 7,
+          total_cost_brl: 0.35,
+        }),
+      );
+      const costTasks = filesystem.viewPage("cost_monitor_tasks", { limit: 20 }).rows;
+      expect(costTasks).toContainEqual(
+        expect.objectContaining({
+          id: "TASK-ORPHAN-REFERENCE",
+          total_tokens: 11,
+          total_cost_brl: 0.55,
+        }),
+      );
+      const developers = filesystem.developerCostAggregate({
+        from: null,
+        to: null,
+        accountIds: ["42"],
+      });
+      expect(developers.rows).toEqual([
+        expect.objectContaining({
+          account_id: "42",
+          login_snapshot: "dev-fixture",
+          prd_count: expect.any(Number),
+          spec_count: expect.any(Number),
+          task_count: 2,
+          run_count: 2,
+          test_count: 1,
+          evidence_count: 1,
+          total_duration_ms: expect.any(Number),
+          completed_task_count: 1,
+          total_cost_brl: 0.9,
+          token_covered_runs: 2,
+          usd_covered_runs: 2,
+          brl_covered_runs: 2,
+          qualification: "verified",
+          completed_tasks: [
+            expect.objectContaining({
+              id: "TASK-CANONICAL",
+              status: "completed",
+              completed_run_id: "RUN-CANONICAL",
+              delivered_by: { account_id: "42" },
+              contributors: [expect.objectContaining({ account_id: "42" })],
+            }),
+          ],
+        }),
+      ]);
+      expect(
+        filesystem.developerCostAggregate({
+          from: "2026-08-08",
+          to: "2026-08-08",
+          accountIds: ["42"],
+        }).rows,
+      ).toEqual([expect.objectContaining({ test_count: 1, evidence_count: 1 })]);
+      expect(
+        filesystem.dailyPeriods({ from: "2026-08-08", to: "2026-08-08" })["2026-08-08"],
+      ).toMatchObject({ validations: 1, evidences: 1 });
+      const operationsDevelopers = filesystem.operationsDeveloperAggregate({
+        from: null,
+        to: null,
+        accountIds: ["42"],
+      });
+      expect(operationsDevelopers.rows).toEqual([
+        expect.objectContaining({
+          account_id: "42",
+          task_count: 2,
+          completed_task_count: 1,
+          status_counts: expect.objectContaining({ completed: 1 }),
+          type_counts: { task: 1 },
+          risk_counts: expect.any(Object),
+          total_duration_ms: expect.any(Number),
+          total_tokens: expect.any(Number),
+          total_cost_brl: 0.9,
+        }),
+      ]);
+    } finally {
+      filesystem.close();
+    }
+  });
+  it("qualifies factual developer deliveries without inventing missing completion or coverage", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const runsRoot = join(root, ".agents", "records", "runs", "2026", "08");
+    const tasksRoot = join(root, ".agents", "records", "tasks", "2026", "08");
+    const assignmentsRoot = join(
+      root,
+      ".agents",
+      "records",
+      "lifecycle",
+      "historical-developer-attribution",
+    );
+    await Promise.all([
+      mkdir(runsRoot, { recursive: true }),
+      mkdir(tasksRoot, { recursive: true }),
+      mkdir(assignmentsRoot, { recursive: true }),
+      mkdir(join(root, ".agents", "config"), { recursive: true }),
+    ]);
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "zaip:\n  enabled: true\n",
+      "utf8",
+    );
+    const task = (id: string, status: string, completedRunId: string | null) =>
+      `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}${completedRunId === null ? "" : `\ncompleted_run_id: ${completedRunId}`}\nrisk: standard\ncreated_at: 2026-08-08T12:00:00.000Z\n---\n# ${id}\n`;
+    await Promise.all([
+      writeFile(
+        join(tasksRoot, "TASK-DELIVERED.md"),
+        task("TASK-DELIVERED", "completed", "RUN-DELIVERED"),
+      ),
+      writeFile(
+        join(tasksRoot, "TASK-NO-COMPLETION.md"),
+        task("TASK-NO-COMPLETION", "completed", null),
+      ),
+      writeFile(
+        join(tasksRoot, "TASK-MISSING-RUN.md"),
+        task("TASK-MISSING-RUN", "completed", "RUN-NOT-FOUND"),
+      ),
+      writeFile(
+        join(tasksRoot, "TASK-NOT-COMPLETED.md"),
+        task("TASK-NOT-COMPLETED", "executing", "RUN-NOT-COMPLETED"),
+      ),
+      writeFile(
+        join(tasksRoot, "TASK-UNKNOWN-COVERAGE.md"),
+        task("TASK-UNKNOWN-COVERAGE", "completed", null),
+      ),
+      writeFile(
+        join(tasksRoot, "TASK-HISTORICAL.md"),
+        task("TASK-HISTORICAL", "completed", "RUN-HISTORICAL"),
+      ),
+    ]);
+    const stream = (
+      id: string,
+      taskId: string,
+      accountId: string | null,
+      day: string,
+      tokens: number | null,
+    ) => {
+      const identity =
+        accountId === null
+          ? null
+          : {
+              schema_version: 1,
+              provider: "github",
+              account_id: accountId,
+              login_snapshot: `dev-${accountId}`,
+              verified_at: `${day}T12:00:00.000Z`,
+              attribution_source: "verified_local_account",
+            };
+      const records: Record<string, unknown>[] = [
+        {
+          schema_version: 2,
+          event_id: `${id}:1`,
+          run_id: id,
+          sequence: 1,
+          occurred_at: `${day}T12:00:00.000Z`,
+          type: "run.started",
+          attribution_status: "attributed",
+          phase: "execution",
+          run_role: "orchestrator",
+          run_purpose: "execution",
+          requires_finalizer: false,
+          execution_kind: "delivery",
+          execution_eligibility: ["delivery"],
+          entrypoint: "task",
+          work_type: "new",
+          storage_mode: "tracked_sanitized",
+          client: "codex",
+          agent: "agent",
+          agent_name: "agent",
+          developer_identity: identity,
+          provider: "openai",
+          model: "gpt-a",
+          reasoning_effort: null,
+          client_thread_id: id,
+          client_turn_id: id,
+          conversation_id: `CONV-${id}`,
+          execution_id: `EXEC-${id}`,
+          task_id: taskId,
+          spec_id: null,
+          prd_id: null,
+          change_id: null,
+          parent_run_id: null,
+          continuation_of_run_id: null,
+          retry_of_run_id: null,
+          agent_invocation_id: `AINV-${id}`,
+          root_agent_invocation_id: `AINV-${id}`,
+          parent_agent_invocation_id: null,
+          invocation_kind: "orchestrator",
+          delegation_depth: 0,
+        },
+      ];
+      if (tokens !== null)
+        records.push({
+          schema_version: 2,
+          event_id: `${id}:2`,
+          run_id: id,
+          sequence: 2,
+          occurred_at: `${day}T12:00:30.000Z`,
+          type: "usage.recorded",
+          phase: "execution",
+          activity_kind: "model_usage",
+          classification_source: "explicit",
+          tokens: {
+            input: tokens,
+            cached_input: 0,
+            output: 0,
+            reasoning: 0,
+            total: tokens,
+            source: "provider_reported",
+          },
+          cost: { usd: tokens / 100, brl: tokens / 20, fx_rate: 5 },
+          provider: "openai",
+          model: "gpt-a",
+          source_segment_key: id,
+          model_call_id: `MCALL-${id}`,
+          runtime: { reasoning_effort: null, service_tier: null },
+          supersedes_event_id: null,
+          source_started_at: `${day}T12:00:00.000Z`,
+          source_finished_at: `${day}T12:01:00.000Z`,
+          duration_ms: null,
+          duration_provenance: null,
+        });
+      records.push({
+        schema_version: 2,
+        event_id: `${id}:3`,
+        run_id: id,
+        sequence: records.length + 1,
+        occurred_at: `${day}T12:01:00.000Z`,
+        type: "run.finished",
+        phase: "execution",
+        status: "completed",
+        duration_ms: 60_000,
+        duration_provenance: "observed",
+      });
+      return `${records.map((record) => JSON.stringify(record)).join("\n")}\n`;
+    };
+    const delivered = stream("RUN-DELIVERED", "TASK-DELIVERED", "42", "2026-08-08", 10);
+    const contributor = stream("RUN-CONTRIBUTOR", "TASK-DELIVERED", "99", "2026-08-08", 3);
+    const noCompletion = stream("RUN-NO-COMPLETION", "TASK-NO-COMPLETION", "42", "2026-08-09", 4);
+    const notCompleted = stream("RUN-NOT-COMPLETED", "TASK-NOT-COMPLETED", "42", "2026-08-09", 5);
+    const unknownCoverage = stream(
+      "RUN-UNKNOWN-COVERAGE",
+      "TASK-UNKNOWN-COVERAGE",
+      "42",
+      "2026-08-09",
+      null,
+    );
+    const historical = stream("RUN-HISTORICAL", "TASK-HISTORICAL", null, "2026-08-09", 2);
+    await Promise.all([
+      writeFile(join(runsRoot, "RUN-DELIVERED.jsonl"), delivered),
+      writeFile(join(runsRoot, "RUN-CONTRIBUTOR.jsonl"), contributor),
+      writeFile(join(runsRoot, "RUN-NO-COMPLETION.jsonl"), noCompletion),
+      writeFile(join(runsRoot, "RUN-NOT-COMPLETED.jsonl"), notCompleted),
+      writeFile(join(runsRoot, "RUN-UNKNOWN-COVERAGE.jsonl"), unknownCoverage),
+      writeFile(join(runsRoot, "RUN-HISTORICAL.jsonl"), historical),
+    ]);
+    const historicalPath = ".agents/records/runs/2026/08/RUN-HISTORICAL.jsonl";
+    const unsigned = {
+      schema_version: 1,
+      manifest_id: "HDA-FIXTURE",
+      created_at: "2026-08-09T12:00:00.000Z",
+      kind: "historical_developer_attribution",
+      assignment: {
+        schema_version: 1,
+        provider: "github",
+        account_id: "199126185",
+        login_snapshot: "zaip-ai",
+        attribution_source: "human_assigned",
+        verified_at: null,
+      },
+      source_streams: [
+        {
+          run_id: "RUN-HISTORICAL",
+          path: historicalPath,
+          content_sha256: createHash("sha256").update(historical).digest("hex"),
+        },
+      ],
+    };
+    await writeFile(
+      join(assignmentsRoot, "HDA-FIXTURE.json"),
+      JSON.stringify({
+        ...unsigned,
+        manifest_hash: createHash("sha256").update(JSON.stringify(unsigned)).digest("hex"),
+      }),
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      const all = filesystem.developerCostAggregate({ from: null, to: null });
+      const deliveredBy42 = all.rows.find((row) => row.account_id === "42")!;
+      expect(deliveredBy42).toMatchObject({
+        qualification: "verified",
+        completed_task_count: 1,
+        run_count: 4,
+        token_covered_runs: 3,
+        usd_covered_runs: 3,
+        brl_covered_runs: 3,
+      });
+      expect(deliveredBy42.completed_tasks).toEqual([
+        expect.objectContaining({
+          id: "TASK-DELIVERED",
+          completed_run_id: "RUN-DELIVERED",
+          delivered_by: { account_id: "42" },
+          contributors: expect.arrayContaining([
+            expect.objectContaining({ account_id: "42" }),
+            expect.objectContaining({ account_id: "99" }),
+          ]),
+        }),
+      ]);
+      // Operations counts completed Tasks from the same canonical Task facts
+      // as its status distribution; no completed_run_id is required there.
+      expect(
+        filesystem
+          .operationsDeveloperAggregate({ from: null, to: null })
+          .rows.find((row) => row.account_id === "42"),
+      ).toMatchObject({
+        completed_task_count: 3,
+        status_counts: expect.objectContaining({ completed: 3 }),
+      });
+      expect(all.rows.find((row) => row.account_id === "199126185")).toMatchObject({
+        qualification: "human_assigned",
+        completed_task_count: 1,
+      });
+      expect(
+        filesystem.developerCostAggregate({
+          from: "2026-08-08",
+          to: "2026-08-08",
+          accountIds: ["42"],
+        }).rows,
+      ).toHaveLength(1);
+      expect(
+        filesystem.developerCostAggregate({
+          from: "2026-08-09",
+          to: "2026-08-09",
+          accountIds: ["42"],
+        }).rows[0],
+      ).toMatchObject({ completed_task_count: 0 });
+      // The real attributed unknown Run remains linked to account 42. Its
+      // coverage gap is explicit; its absent measures are never a zero.
+      const unknownDay = filesystem.developerCostAggregate({
+        from: "2026-08-09",
+        to: "2026-08-09",
+        accountIds: ["42"],
+      }).rows[0]!;
+      expect(unknownDay).toMatchObject({
+        run_count: 3,
+        token_covered_runs: 2,
+        usd_covered_runs: 2,
+        brl_covered_runs: 2,
+      });
+      expect(unknownDay.total_tokens).toBe(9);
+      expect(
+        filesystem.dailyPeriods({ from: "2026-08-09", to: "2026-08-09" })["2026-08-09"],
+      ).toMatchObject({
+        runs: 4,
+        usage: {
+          total_tokens: { known_sum: 11, unknown: 1 },
+          cost: { known_sum: 0.55, unknown: 1 },
+        },
+      });
+    } finally {
+      filesystem.close();
+    }
+    await writeFile(join(assignmentsRoot, "HDA-FIXTURE.json"), "{corrupt");
+    await rebuildSqliteReadModel(root, { forceCanonical: true });
+    const corrupt = new SqliteReadModelFileSystem(root);
+    try {
+      expect(
+        corrupt.developerCostAggregate({ from: null, to: null }).rows.map((row) => row.account_id),
+      ).not.toContain("199126185");
+    } finally {
+      corrupt.close();
+    }
+  });
+  it("prefers the canonical started-to-finished interval over a token estimate", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+      "utf8",
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-2:1",
+      run_id: "RUN-2",
+      sequence: 1,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "execution",
+      run_role: "orchestrator",
+      run_purpose: "execution",
+      requires_finalizer: false,
+      execution_kind: "delivery",
+      execution_eligibility: ["delivery"],
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "agent",
+      agent_name: "agent",
+      provider: "openai",
+      model: "gpt-5",
+      reasoning_effort: null,
+      client_thread_id: "thread",
+      client_turn_id: "turn",
+      conversation_id: "CONV-2",
+      execution_id: "EXEC-2",
+      task_id: "TASK-2",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      agent_invocation_id: "AINV-2",
+      root_agent_invocation_id: "AINV-2",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-2:2",
+      run_id: "RUN-2",
+      sequence: 2,
+      occurred_at: "2026-08-01T12:10:00.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 4_000_000,
+        cached_input: 0,
+        output: 0,
+        reasoning: 0,
+        total: 4_000_000,
+        source: "provider_reported",
+      },
+      cost: { usd: null, brl: null, fx_rate: null },
+      provider: "openai",
+      model: "gpt-5",
+      source_segment_key: "segment",
+      model_call_id: "MCALL-2",
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-2:3",
+      run_id: "RUN-2",
+      sequence: 3,
+      occurred_at: "2026-08-01T12:30:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: null,
+      duration_provenance: "unavailable",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-2.jsonl"),
+      `${[started, usage, finished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database
+        .prepare(
+          "SELECT duration_ms, duration_provenance FROM zaip_aios_activities WHERE payload_type IS NULL",
+        )
+        .get(),
+    ).toEqual({ duration_ms: 1_800_000, duration_provenance: "attributed_token_active" });
+    database.close();
+  });
+});