@zaip-ai/cli 2.6.0 → 3.1.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-group-projection.test.ts

@@ -0,0 +1,94 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { materializeCostGroupDailyProjection } from "./sqlite-cost-group-projection.js";
+import { baseViewSql } from "./sqlite-schema-base-views.js";
+
+it("evaluates the invocation population once across all eight daily groups with legacy parity", () => {
+  const database = new DatabaseSync(":memory:");
+  let costReads = 0;
+  database.function("observed_cost", (id) => {
+    costReads++;
+    return id === 1 ? 0 : null;
+  });
+  try {
+    database.exec(`CREATE TABLE inputs(id INTEGER); INSERT INTO inputs VALUES (1),(2);
+      CREATE VIEW invocations AS SELECT '2026-09-15' AS occurred_day_sp,
+      'e' AS execution_id, 'a' AS zaip_agent, 'p' AS provider, 'm' AS model,
+      't' AS task_id, 's' AS spec_id, 'r' AS prd_id, 'c' AS conversation_id,
+      1 AS llm_call_count, NULL AS duration_ms, 2 AS input_tokens,
+      NULL AS cached_input_tokens, 3 AS output_tokens, NULL AS reasoning_tokens,
+      5 AS total_tokens, observed_cost(id) AS cost_usd, NULL AS cost_brl FROM inputs;`);
+    const definition = /CREATE VIEW cost_monitor_group_daily_cache AS ([^;]+);/.exec(
+      baseViewSql,
+    )?.[1];
+    if (!definition) throw new Error("Canonical daily group SQL absent");
+    database.exec(`CREATE VIEW measured AS ${definition};`);
+    const actual = database.prepare("SELECT * FROM measured ORDER BY group_kind").all();
+    expect(actual).toHaveLength(8);
+    expect(costReads).toBe(2);
+    const reference = definition
+      .replace(/WITH group_invocations AS MATERIALIZED \([^)]*\) /, "")
+      .replaceAll("FROM group_invocations", "FROM invocations");
+    costReads = 0;
+    const expected = database.prepare(`SELECT * FROM (${reference}) ORDER BY group_kind`).all();
+    expect(costReads).toBe(16);
+    expect(actual).toEqual(expected);
+    for (const row of actual) {
+      expect(row.invocation_count).toBe(2);
+      expect(row.total_cost_usd).toBe(0);
+      expect(row.total_cost_brl).toBeNull();
+      expect(row.total_duration).toBeNull();
+    }
+  } finally {
+    database.close();
+  }
+});
+
+it("materializes exact labels without evaluating unrelated entity metrics", () => {
+  const database = new DatabaseSync(":memory:");
+  let irrelevantReads = 0;
+  database.function("unrelated_metric", () => {
+    irrelevantReads++;
+    throw new Error("Label projection must not evaluate unrelated metrics");
+  });
+  try {
+    database.exec(
+      `CREATE TABLE zaip_vw_cost_monitor_group_daily_cache(group_kind TEXT, day TEXT, group_value TEXT, cost REAL);`,
+    );
+    const insert = database.prepare(
+      "INSERT INTO zaip_vw_cost_monitor_group_daily_cache VALUES (?, '2026-09-15', ?, 2)",
+    );
+    for (const kind of ["task", "spec", "prd", "execution", "conversation"]) {
+      insert.run(kind, kind);
+      insert.run(kind, "missing");
+      insert.run(kind, null);
+      database.exec(
+        `CREATE VIEW zaip_vw_${kind}s AS SELECT '${kind}' AS id, 'Title' AS title, 'blocked' AS status, 'standard' AS risk, unrelated_metric() AS expensive_unused;`,
+      );
+    }
+    materializeCostGroupDailyProjection(database);
+    const rows = database
+      .prepare("SELECT * FROM cost_group_entity_projection ORDER BY group_kind, group_value")
+      .all();
+    expect(rows).toHaveLength(10);
+    for (const row of rows) {
+      expect(row.status).toBe(row.group_value === "missing" ? null : "blocked");
+      const titled =
+        row.group_value !== "missing" && ["task", "spec", "prd"].includes(String(row.group_kind));
+      expect(row.title).toBe(titled ? "Title" : null);
+      expect(row.risk).toBe(titled ? "standard" : null);
+    }
+    expect(irrelevantReads).toBe(0);
+    materializeCostGroupDailyProjection(database);
+    expect(
+      database
+        .prepare("SELECT * FROM cost_group_entity_projection ORDER BY group_kind, group_value")
+        .all(),
+    ).toEqual(rows);
+    expect(database.prepare("SELECT COUNT(*) AS n FROM cost_group_daily_projection").get()?.n).toBe(
+      15,
+    );
+  } finally {
+    database.close();
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-group-projection.ts

@@ -15,11 +15,11 @@ export function materializeCostGroupDailyProjection(database: DatabaseSync): voi
     CREATE TABLE IF NOT EXISTS cost_group_entity_projection(group_kind TEXT, group_value TEXT, title TEXT, status TEXT, risk TEXT);
     DELETE FROM cost_group_entity_projection;
     INSERT INTO cost_group_entity_projection
-      WITH tasks AS MATERIALIZED (SELECT * FROM zaip_vw_tasks),
-        specs AS MATERIALIZED (SELECT * FROM zaip_vw_specs),
-        prds AS MATERIALIZED (SELECT * FROM zaip_vw_prds),
-        executions AS MATERIALIZED (SELECT * FROM zaip_vw_executions),
-        conversations AS MATERIALIZED (SELECT * FROM zaip_vw_conversations)
+      WITH tasks AS MATERIALIZED (SELECT id, title, status, risk FROM zaip_vw_tasks),
+        specs AS MATERIALIZED (SELECT id, title, status, risk FROM zaip_vw_specs),
+        prds AS MATERIALIZED (SELECT id, title, status, risk FROM zaip_vw_prds),
+        executions AS MATERIALIZED (SELECT id, status FROM zaip_vw_executions),
+        conversations AS MATERIALIZED (SELECT id, status FROM zaip_vw_conversations)
       SELECT 'task' AS group_kind, groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'task' AND group_value IS NOT NULL) groups

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-duration-lookup.test.ts

@@ -0,0 +1,59 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { baseViewSql } from "./sqlite-schema-base-views.js";
+
+it("uses indexed duration lookup with exact legacy sums and nulls and no duplicate Run rows", () => {
+  const db = new DatabaseSync(":memory:");
+  try {
+    db.exec(
+      "CREATE TABLE zaip_aios_activities(activity_row_id TEXT, payload_type TEXT, payload_json TEXT);",
+    );
+    const insert = db.prepare("INSERT INTO zaip_aios_activities VALUES(?,?,?)");
+    for (const id of ["known", "zero", "unknown", "missing"]) insert.run(id, null, null);
+    for (const [id, values] of [
+      ["known", [3, 5, null]],
+      ["zero", [0]],
+      ["unknown", [null]],
+      ["unrelated", [900]],
+    ] as const)
+      for (const duration of values)
+        insert.run(
+          `fact-${id}`,
+          "duration_allocation",
+          JSON.stringify({ activity_row_id: id, attributed_token_active_ms: duration }),
+        );
+    insert.run(
+      "technical",
+      "other",
+      JSON.stringify({ activity_row_id: "known", attributed_token_active_ms: 999 }),
+    );
+    const index = /CREATE INDEX zaip_activities_duration_activity[^;]+;/.exec(baseViewSql)?.[0];
+    const view = /CREATE VIEW activities AS\s+([^;]+);/.exec(baseViewSql)?.[1];
+    if (!index || !view) throw new Error("Canonical indexed duration SQL missing");
+    db.exec(`${index} CREATE VIEW activities AS ${view};`);
+    const query =
+      "SELECT activity_row_id,attributed_token_active_ms FROM activities ORDER BY activity_row_id";
+    const actual = db.prepare(query).all();
+    const expected = db
+      .prepare(`SELECT a.activity_row_id,f.duration AS attributed_token_active_ms
+      FROM zaip_aios_activities a LEFT JOIN (
+        SELECT json_extract(payload_json,'$.activity_row_id') AS activity_row_id,
+        SUM(json_extract(payload_json,'$.attributed_token_active_ms')) AS duration
+        FROM zaip_aios_activities WHERE payload_type='duration_allocation' GROUP BY activity_row_id
+      ) f USING(activity_row_id) WHERE a.payload_type IS NULL ORDER BY a.activity_row_id`)
+      .all();
+    expect(actual).toEqual(expected);
+    expect(actual).toHaveLength(4);
+    expect(actual.map((row) => row.attributed_token_active_ms)).toEqual([8, null, null, 0]);
+    const plan = db.prepare(`EXPLAIN QUERY PLAN ${query}`).all();
+    expect(
+      plan.some((row) =>
+        String(row.detail).includes("zaip_activities_duration_activity (<expr>=?)"),
+      ),
+    ).toBe(true);
+    const labelPlan = db.prepare("EXPLAIN QUERY PLAN SELECT activity_row_id FROM activities").all();
+    expect(labelPlan.some((row) => String(row.detail).includes("CORRELATED"))).toBe(false);
+  } finally {
+    db.close();
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-entity-label-views.test.ts

@@ -0,0 +1,72 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { baseViewSql } from "./sqlite-schema-base-views.js";
+
+it("preserves canonical precedence and legacy labels without repeated payload or metric expansion", () => {
+  const db = new DatabaseSync(":memory:");
+  let payloadReads = 0;
+  let metricReads = 0;
+  db.function("payload_origin", (value) => {
+    payloadReads++;
+    return value;
+  });
+  db.function("unused_metric", () => {
+    metricReads++;
+    return 42;
+  });
+  try {
+    db.exec(`
+      CREATE TABLE inputs(id TEXT, status TEXT, created_at TEXT, occurred_day_sp TEXT, origin_type TEXT, origin_id TEXT);
+      INSERT INTO inputs VALUES
+        ('e1','blocked','2026-09-01','2026-09-01','interaction','c1'),
+        ('e2','completed','2026-09-02','2026-09-02','interaction','c1'),
+        ('e3',NULL,'2026-09-03','2026-09-03','task','not-conversation'),
+        ('e4','failed','2026-09-04','2026-09-04','interaction',NULL);
+      CREATE VIEW canonical_executions AS SELECT id,status,created_at,occurred_day_sp,origin_type,
+        payload_origin(origin_id) AS origin_id FROM inputs;
+      CREATE TABLE zaip_aios_activities(payload_type TEXT, execution_id TEXT, conversation_id TEXT,
+        status TEXT, occurred_at TEXT, occurred_day_sp TEXT);
+      INSERT INTO zaip_aios_activities VALUES
+        (NULL,'e1','c1','failed','2026-08-01','2026-08-01'),
+        (NULL,'legacy','legacy-c','blocked','2026-09-05','2026-09-05'),
+        (NULL,'legacy','legacy-c','completed','2026-09-06','2026-09-06'),
+        (NULL,'unknown','unknown-c',NULL,NULL,NULL),
+        ('technical','fake','fake-c','completed','2026-01-01','2026-01-01'),
+        (NULL,NULL,NULL,'completed','2026-01-01','2026-01-01');
+      CREATE VIEW activities AS SELECT a.*, f.metric FROM zaip_aios_activities a
+        LEFT JOIN (SELECT execution_id, SUM(unused_metric()) AS metric FROM zaip_aios_activities GROUP BY execution_id) f
+        USING(execution_id) WHERE a.payload_type IS NULL;
+    `);
+    const reference = {
+      executions: `SELECT id,status,created_at AS occurred_at,occurred_day_sp FROM canonical_executions
+        UNION ALL SELECT execution_id,MAX(status),MIN(occurred_at),MIN(occurred_day_sp)
+        FROM activities WHERE execution_id IS NOT NULL AND NOT EXISTS
+        (SELECT 1 FROM canonical_executions c WHERE c.id=activities.execution_id) GROUP BY execution_id`,
+      conversations: `SELECT origin_id AS id,MAX(status) AS status,MIN(created_at) AS occurred_at,MIN(occurred_day_sp) AS occurred_day_sp
+        FROM canonical_executions WHERE origin_type='interaction' AND origin_id IS NOT NULL GROUP BY origin_id
+        UNION ALL SELECT conversation_id,MAX(status),MIN(occurred_at),MIN(occurred_day_sp)
+        FROM activities WHERE conversation_id IS NOT NULL AND NOT EXISTS
+        (SELECT 1 FROM canonical_executions c WHERE c.origin_type='interaction' AND c.origin_id=activities.conversation_id) GROUP BY conversation_id`,
+    };
+    for (const name of ["executions", "conversations"] as const) {
+      const expected = db.prepare(`SELECT * FROM (${reference[name]}) ORDER BY id`).all();
+      const repeatedReads = payloadReads;
+      payloadReads = 0;
+      metricReads = 0;
+      const definition = new RegExp(`CREATE VIEW ${name} AS\\s+([^;]+);`).exec(baseViewSql)?.[1];
+      if (!definition) throw new Error(`Missing canonical view ${name}`);
+      const actual = db.prepare(`SELECT * FROM (${definition}) ORDER BY id`).all();
+      expect(actual).toEqual(expected);
+      expect(actual.some((row) => String(row.id).startsWith("fake"))).toBe(false);
+      expect(metricReads).toBe(0);
+      if (name === "conversations") {
+        expect(payloadReads).toBe(4);
+        expect(repeatedReads).toBeGreaterThan(payloadReads);
+        expect(actual.find((row) => row.id === "c1")?.status).toBe("completed");
+        expect(actual.find((row) => row.id === "unknown-c")?.status).toBeNull();
+      }
+    }
+  } finally {
+    db.close();
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-file-index.test.ts

@@ -0,0 +1,69 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { rebuildSqliteReadModel, validateSqliteReadModelSchema } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+it("indexes exact and LIKE file lookups without changing case or prefix membership", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-file-index-"));
+  let database: DatabaseSync | undefined;
+  try {
+    await prepareMultiProviderFixture(root);
+    await rebuildSqliteReadModel(root);
+    const path = join(root, ".local/sqlite/zaip-aios-dashboard.sqlite");
+    database = new DatabaseSync(path);
+    const reader = database;
+    const queries = [
+      {
+        sql: "SELECT path, content FROM zaip_vw_files WHERE path = ?",
+        arg: ".agents/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".AGENTS/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/missing/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path = ?",
+        arg: ".AGENTS/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+    ];
+    const indexed = queries.map(({ sql, arg, index }) => {
+      const plan = reader.prepare(`EXPLAIN QUERY PLAN ${sql}`).all(arg);
+      expect(JSON.stringify(plan)).toContain(`USING INDEX ${index}`);
+      return reader.prepare(sql).all(arg);
+    });
+    expect(indexed[0]).toHaveLength(1);
+    expect(indexed[1]?.length).toBeGreaterThan(1);
+    expect(indexed[2]).toEqual(indexed[1]);
+    expect(indexed[3]).toEqual([]);
+    expect(indexed[4]).toEqual([]);
+    const view = database
+      .prepare("SELECT sql FROM sqlite_master WHERE name='zaip_vw_files'")
+      .get() as { sql: string };
+    database.exec("DROP VIEW zaip_vw_files;");
+    database.exec(view.sql.replace(" INDEXED BY zaip_activities_file_path", ""));
+    database.exec("DROP INDEX zaip_activities_file_path;");
+    expect(() => validateSqliteReadModelSchema(path)).toThrow(/missing required indexes/);
+    for (const [position, { sql, arg }] of queries.entries()) {
+      expect(database.prepare(sql).all(arg)).toEqual(indexed[position]);
+    }
+  } finally {
+    database?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-first-fold-cache.ts

@@ -231,7 +231,9 @@ export function readFirstFoldViewport(
       SELECT COALESCE(status, 'draft') AS status, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(status, 'draft'))
   ), task_risk AS (
     SELECT json_group_object(risk, task_count) AS task_risk_json FROM (
-      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(risk, 'standard'))
+      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items
+      WHERE entity_kind='task' AND COALESCE(status, 'draft') <> 'draft'
+      GROUP BY COALESCE(risk, 'standard'))
   )
   SELECT totals.*, run_totals.*, duration_totals.*, bounds.*, item_totals.*, task_status.*, task_risk.*
     FROM totals CROSS JOIN run_totals CROSS JOIN duration_totals CROSS JOIN bounds

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-force-canonical.test.ts

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
 
 const roots: string[] = [];
@@ -17,12 +17,14 @@ async function fixture(): Promise<string> {
 }
 
 afterEach(async () => {
+  vi.restoreAllMocks();
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
 describe("forceCanonical SQLite refresh", () => {
   it("bypasses a healthy generation and verifies canonical sources again", async () => {
     const root = await fixture();
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const initial = await rebuildSqliteReadModel(root);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
       cache: "generation",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-refresh.test.ts

@@ -173,6 +173,8 @@ describe("incremental refresh preserves historical facts", () => {
   it("updates and removes changed sources in place with full-build query parity and untouched historical payloads", async () => {
     const root = await fixture();
     const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    // This scenario exercises settled historical checkpoints, not rapid writes.
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const first = await rebuildSqliteReadModel(root);
     const history = inspect(first.path, historySql);
     expect(history).toHaveLength(2);

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-projections.ts

@@ -15,6 +15,7 @@ import {
   knownSum,
   saoPauloDay,
 } from "./sqlite-read-model-canonical.js";
+import { reportSqliteReadModelLaunchProgress as progress } from "./sqlite-read-model-launch-progress.js";
 import { readModelSchemaVersion } from "./sqlite-read-model-schema.js";
 import { baseViewSql } from "./sqlite-schema-base-views.js";
 import { dashboardViewSql } from "./sqlite-schema-dashboard-views.js";
@@ -234,6 +235,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
     }
   };
   materializeSharedCreationAllocations();
+  progress("projection_allocations_ready", 78, "Rateios de criação concluídos.");
   const canonicalRunCount = Number(
     (
       database
@@ -352,6 +354,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
     insertConfiguredProvider.run(configuredModel.provider);
   }
   const costDimensionAggregates = buildCostDimensionAggregates(database, agentProfiles);
+  progress("projection_costs_ready", 78, "Agregados de custo concluídos.");
   // The rebuild scratch tables above are intentionally TEMP only. Persist
   // their technical inputs as typed payload activities so the on-disk
   // model has one fact plus its three declared dimensions, never hidden
@@ -443,6 +446,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
     });
   }
   synchronizePayloadRows(database, "cost_dimension_aggregate_v1", dimensionPayloads);
+  progress("projection_payloads_ready", 78, "Projeções incrementais persistidas.");
   // Keep canonical TEMP references outside the public-view name rewriter.
   database.exec(
     hasPersistentSchema
@@ -454,6 +458,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
           .replace(/CREATE INDEX cost_dimension_facts_[A-Za-z_]+ ON [^;]+;/g, "")
       : rebuildCostInvocationDimensionFactsSql,
   );
+  progress("projection_facts_ready", 78, "Fatos das dimensões concluídos.");
   const viewSql = baseViewSql + dashboardViewSql;
   // Every SQLite view has a single discoverable namespace.  References in
   // the view definitions are rewritten from their concise source aliases
@@ -478,6 +483,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
     },
   );
   if (!hasPersistentSchema) database.exec(deduplicatedViewSql);
+  progress("projection_views_ready", 78, "Views públicas preparadas.");
   // One row per stable GitHub account. Costs are summed from the single
   // canonical Run fact, while delivery is joined exclusively through the
   // Task's completed_run_id (never inferred from a branch or latest Run).
@@ -523,11 +529,14 @@ export function materializeDashboardProjections(input: ProjectionInput) {
       : developerProjectionSql,
   );
   materializeCostGroupDailyProjection(database);
+  progress("projection_daily_ready", 78, "Agrupamentos diários concluídos.");
   materializeOperationsWorkProjection(database);
+  progress("projection_operations_ready", 78, "Projeção operacional concluída.");
   // Persist the complete unfiltered invocation projection while the seed
   // still owns the compact canonical facts. Runtime pages can then slice
   // 10/100 rows without expanding the pricing view for every request.
   const costAgentInvocationProjection = readCostInvocationProjection(database);
+  progress("projection_invocations_ready", 78, "Projeção de invocações concluída.");
   synchronizePayloadRows(
     database,
     "cost_agent_invocation_projection_v1",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-runs.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { DatabaseSync } from "node:sqlite";
-import { pricingCatalogSchema, resolveHistoricalDeveloperAttribution } from "@zaip-ai/costs";
+import { prepareHistoricalDeveloperAttribution, pricingCatalogSchema } from "@zaip-ai/costs";
 import {
   foldRunV2Records,
   parseRunV2JsonLines,
@@ -97,7 +97,7 @@ export function materializeCanonicalRuns(input: RunMaterializationInput) {
       .all() as Array<{ content: string }>
   ).flatMap((row) => {
     try {
-      return [JSON.parse(row.content)];
+      return [prepareHistoricalDeveloperAttribution(JSON.parse(row.content))];
     } catch {
       return [];
     }
@@ -117,8 +117,7 @@ export function materializeCanonicalRuns(input: RunMaterializationInput) {
       };
     for (const candidate of historicalDeveloperManifests) {
       try {
-        const resolved = resolveHistoricalDeveloperAttribution({
-          manifest: candidate,
+        const resolved = candidate({
           run_id: String(JSON.parse(row.content.split(/\r?\n/u)[0] ?? "{}").run_id ?? ""),
           path: row.path,
           content: row.content,
@@ -480,7 +479,7 @@ export function materializeCanonicalRuns(input: RunMaterializationInput) {
         const audit = usagePricingAudit(record, fold, pricingCatalog, fxRate);
         insertUsageSegment.run(
           agentRunId,
-          record.provider ?? null,
+          canonicalProvider(record.provider, record.model ?? started.model, started.client),
           record.model ?? null,
           audit.serviceTier,
           record.runtime?.reasoning_effort ?? null,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-period-averages.ts

@@ -0,0 +1,46 @@
+import { summarizeCostPeriodAverages } from "@zaip-ai/dashboard-cost-monitor/server";
+
+export function sqlitePeriodTotals(rows: readonly Record<string, unknown>[]) {
+  const totals: Record<string, number | null> = {};
+  for (const key of [
+    "prd_count",
+    "spec_count",
+    "task_count",
+    "total_run_count",
+    "validation_count",
+    "evidence_count",
+    "total_duration",
+    "total_tokens",
+    "total_cost_usd",
+    "total_cost_brl",
+  ]) {
+    const values = rows
+      .map((row) => row[key])
+      .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
+    totals[key] = values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
+  }
+  totals.duration_known = totals.total_duration ?? 0;
+  totals.duration_unknown = rows.filter((row) => typeof row.total_duration !== "number").length;
+  return totals;
+}
+
+/** Compute before pagination, over exactly the filtered period population. */
+export function sqlitePeriodAverages(rows: readonly Record<string, unknown>[]) {
+  const adapted = rows.map((row) => {
+    const value = (key: string) =>
+      typeof row[key] === "number" && Number.isFinite(row[key]) ? (row[key] as number) : null;
+    return {
+      task_count: value("task_count"),
+      spec_count: value("spec_count"),
+      prd_count: value("prd_count"),
+      duration_ms: value("total_duration"),
+      total_tokens: value("total_tokens"),
+      estimated_usd: value("total_cost_usd"),
+      estimated_brl: value("total_cost_brl"),
+    };
+  });
+  return {
+    BRL: summarizeCostPeriodAverages(adapted, "BRL"),
+    USD: summarizeCostPeriodAverages(adapted, "USD"),
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-provider-alias-parity.test.ts

@@ -0,0 +1,50 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+it.each([
+  "CODEX",
+  "codex",
+  "unavailable",
+])("keeps canonical activity and usage-segment provider consistent for %s without rewriting records", async (provider) => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-provider-parity-"));
+  try {
+    const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    const path = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const source = `${[
+      { ...started, provider, model: "gpt-a" },
+      usage(2, provider, "gpt-a", 10, 5),
+      { ...finished, event_id: "RUN-MULTI:3", sequence: 3 },
+    ]
+      .map((row) => JSON.stringify(row))
+      .join("\n")}\n`;
+    await writeFile(path, source);
+    const result = await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(result.path, { readOnly: true });
+    try {
+      const expected = provider === "unavailable" ? null : "openai";
+      expect(
+        database
+          .prepare(
+            "SELECT provider FROM zaip_aios_activities WHERE run_id='RUN-MULTI' AND payload_type IS NULL",
+          )
+          .get(),
+      ).toMatchObject({ provider: expected });
+      const segments = database
+        .prepare(
+          "SELECT json_extract(payload_json,'$.provider') AS provider, json_extract(payload_json,'$.cost_brl') AS cost_brl FROM zaip_aios_activities WHERE payload_type='usage_segment' AND json_extract(payload_json,'$.agent_invocation_id')='AINV-MULTI'",
+        )
+        .all();
+      expect(segments).toEqual([{ provider: expected, cost_brl: 5 }]);
+    } finally {
+      database.close();
+    }
+    expect(await readFile(path, "utf8")).toBe(source);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});