@zaip-ai/cli 2.6.0 → 3.0.0

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

@@ -480,7 +480,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 });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-filtered-dimension.ts

@@ -1,3 +1,4 @@
+import { sqlitePeriodAverages, sqlitePeriodTotals } from "./sqlite-period-averages.js";
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
@@ -9,6 +10,8 @@ export function readFilteredDimension(
 ) {
   const temporalCostGroup =
     filteredCostGroup === "day" || filteredCostGroup === "month" || filteredCostGroup === "year";
+  let periodAverages: ReturnType<typeof sqlitePeriodAverages> | undefined;
+  let periodTotals: ReturnType<typeof sqlitePeriodTotals> | undefined;
 
   if (temporalCostGroup && input.workType) {
     // No canonical work_type exists at invocation grain, including for
@@ -20,6 +23,8 @@ export function readFilteredDimension(
       limit: Math.min(200, Math.max(1, input.limit ?? 50)),
       total_count: 0,
       has_more: false,
+      period_averages: sqlitePeriodAverages([]),
+      totals: sqlitePeriodTotals([]),
       rows: [],
     };
   }
@@ -152,9 +157,11 @@ export function readFilteredDimension(
       : "total_cost_brl DESC, key";
   let rows = context.database
     .prepare(
-      `${facts} SELECT ${groupExpression} AS key, ${groupExpression} AS label, ${groupExpression} AS period_key, MIN(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS start_day, MAX(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS end_day, COUNT(*) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.source_event_count) AS source_event_count, NULL AS total_duration, SUM(i.input_tokens) AS total_input_tokens, SUM(i.cached_input_tokens) AS total_cached_input_tokens, SUM(i.output_tokens) AS total_output_tokens, SUM(i.reasoning_tokens) AS total_reasoning_tokens, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM facts i WHERE ${where} GROUP BY ${groupExpression} ORDER BY ${order} LIMIT ? OFFSET ?`,
+      `${facts} SELECT ${groupExpression} AS key, ${groupExpression} AS label, ${groupExpression} AS period_key, MIN(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS start_day, MAX(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS end_day, COUNT(*) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.source_event_count) AS source_event_count, NULL AS total_duration, SUM(i.input_tokens) AS total_input_tokens, SUM(i.cached_input_tokens) AS total_cached_input_tokens, SUM(i.output_tokens) AS total_output_tokens, SUM(i.reasoning_tokens) AS total_reasoning_tokens, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM facts i WHERE ${where} GROUP BY ${groupExpression} ORDER BY ${order}${temporalCostGroup ? "" : " LIMIT ? OFFSET ?"}`,
     )
-    .all(...values, limit, offset) as Array<Record<string, unknown>>;
+    .all(...values, ...(temporalCostGroup ? [] : [limit, offset])) as Array<
+    Record<string, unknown>
+  >;
   if (temporalCostGroup) {
     const canonicalFilter = {
       from: input.from ?? null,
@@ -268,6 +275,8 @@ export function readFilteredDimension(
       };
     });
     total_count = allRows.length;
+    periodAverages = sqlitePeriodAverages(allRows);
+    periodTotals = sqlitePeriodTotals(allRows);
     rows = allRows.slice(offset, offset + limit);
     for (const row of rows) {
       const key = String(row.period_key);
@@ -287,6 +296,8 @@ export function readFilteredDimension(
     limit,
     total_count,
     has_more: offset + rows.length < total_count,
+    ...(periodAverages === undefined ? {} : { period_averages: periodAverages }),
+    ...(periodTotals === undefined ? {} : { totals: periodTotals }),
     rows,
   };
 }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-summary.ts

@@ -79,7 +79,8 @@ export function queryCostMonitorSummaryAggregate(
   const sourceDay =
     "date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours')";
   const clauses = [
-    "(a.total_tokens IS NOT NULL OR a.cost_brl IS NOT NULL OR a.cost_usd IS NOT NULL)",
+    // Availability affects coverage, not membership. Excluding unknown Runs
+    // silently inflated coverage and made Cost Monitor disagree with Operations.
     `(? IS NULL OR ${sourceDay} >= ?)`,
     `(? IS NULL OR ${sourceDay} <= ?)`,
   ];
@@ -131,7 +132,7 @@ export function queryCostMonitorSummaryAggregate(
       SELECT ${sourceDay} AS day,
         CASE WHEN a.phase='conversation' THEN 'conversation'
              WHEN a.phase='planning' THEN 'planning' ELSE 'execution' END AS phase_key,
-        a.task_id, a.model, a.agent_run_id, a.activity_source_kind,
+        a.task_id, a.model, a.agent_run_id, a.activity_source_kind, a.work_type AS work_key,
         a.source_event_count AS event_count,
         a.attributed_token_active_ms AS duration_ms,
         a.input_tokens, a.cached_input_tokens, a.output_tokens, a.reasoning_tokens,
@@ -158,8 +159,8 @@ export function queryCostMonitorSummaryAggregate(
   // population is evaluated once rather than once per dashboard widget.
   const factRows = context.database
     .prepare(`${selected}
-        SELECT day, phase_key, ${aggregateColumns}
-        FROM selected GROUP BY day, phase_key ORDER BY day, phase_key`)
+        SELECT day, phase_key, work_key, ${aggregateColumns}
+        FROM selected GROUP BY day, phase_key, work_key ORDER BY day, phase_key, work_key`)
     .all(...values) as Array<Record<string, unknown>>;
   const nullableColumns = [
     "duration_ms",
@@ -219,11 +220,13 @@ export function queryCostMonitorSummaryAggregate(
         SELECT entity_kind AS kind, id FROM canonical_work_items
       ), work_item_days AS (
         SELECT entity_kind AS kind, id, occurred_day_sp AS day FROM canonical_work_items
+          WHERE entity_kind <> 'task' OR COALESCE(status, 'draft') <> 'draft'
         UNION ALL
         SELECT 'task', a.task_id, MIN(a.occurred_day_sp) FROM activities a
           LEFT JOIN canonical_ids c ON c.kind='task' AND c.id=a.task_id
           WHERE a.task_id IS NOT NULL AND c.id IS NULL
           GROUP BY a.task_id
+          HAVING COALESCE(MAX(a.work_item_status), 'draft') <> 'draft'
         UNION ALL
         SELECT 'spec', a.spec_id, MIN(a.occurred_day_sp) FROM activities a
           LEFT JOIN canonical_ids c ON c.kind='spec' AND c.id=a.spec_id
@@ -301,7 +304,22 @@ export function queryCostMonitorSummaryAggregate(
   const planning = stripDurationPopulation(metric(byKey.get("planning")));
   const execution = stripDurationPopulation(metric(byKey.get("execution")));
   const total = stripDurationPopulation(metric(byKey.get("total")));
-  const emptyMetric = stripDurationPopulation(metric());
+  const newWork = stripDurationPopulation(
+    metric(
+      rollup(
+        "new",
+        factRows.filter((row) => row.work_key === "new"),
+      ),
+    ),
+  );
+  const rework = stripDurationPopulation(
+    metric(
+      rollup(
+        "rework",
+        factRows.filter((row) => row.work_key === "rework"),
+      ),
+    ),
+  );
   const financialByDay = new Map(dailyRows.map((row) => [String(row.key), row]));
   const structuralByDay = new Map(structuralRows.map((row) => [String(row.day), row]));
   const days = [...new Set([...financialByDay.keys(), ...structuralByDay.keys()])].sort();
@@ -464,8 +482,8 @@ export function queryCostMonitorSummaryAggregate(
       planning,
       execution,
       total,
-      new_work: total,
-      rework: emptyMetric,
+      new_work: newWork,
+      rework,
     },
     task_count: number(totalRow?.task_count),
     model_groups,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-temporal-dimension.ts

@@ -1,3 +1,4 @@
+import { sqlitePeriodAverages } from "./sqlite-period-averages.js";
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
@@ -127,6 +128,7 @@ export function readTemporalDimension(
     total_count: allRows.length,
     has_more: offset + rows.length < allRows.length,
     totals,
+    period_averages: sqlitePeriodAverages(allRows),
     rows,
   };
 }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts

@@ -6,6 +6,7 @@ import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read
 import { expectPersistedFirstFoldCaches } from "./sqlite-read-model-cache.test-support.js";
 
 const roots: string[] = [];
+const readers = new Set<SqliteReadModelFileSystem>();
 const sqliteTestTempRoot = join(
   resolve(import.meta.dirname, "../../../../../.."),
   ".tmp",
@@ -16,6 +17,8 @@ async function createSqliteTestRoot(): Promise<string> {
   return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
 }
 afterEach(async () => {
+  for (const reader of readers) reader.close();
+  readers.clear();
   vi.useRealTimers();
   vi.restoreAllMocks();
   await Promise.all(
@@ -216,6 +219,7 @@ describe("SQLite dashboard read model", () => {
       );
     await rebuildSqliteReadModel(root);
     const filesystem = new SqliteReadModelFileSystem(root);
+    readers.add(filesystem);
     expect(filesystem.firstFoldAggregate({ from: null, to: null }).execution_day_count).toBe(2);
     expect(filesystem.firstFoldAggregate({ from: null, to: null }).duration_ms).toBe(2_400_000);
     expect(filesystem.topTasks({ from: null, to: null })).toMatchObject([
@@ -386,7 +390,7 @@ describe("SQLite dashboard read model", () => {
     expect(operationDays["2026-08-02"]).toMatchObject({
       runs: 2,
       specs: 1,
-      tasks: 1,
+      tasks: 0,
       validations: 1,
       evidences: 0,
       usage: {
@@ -398,7 +402,7 @@ describe("SQLite dashboard read model", () => {
     expect(filesystem.viewPage("operations_daily", { limit: 50 }).rows).toContainEqual(
       expect.objectContaining({
         day: "2026-08-02",
-        task_count: 1,
+        task_count: 0,
         spec_count: 1,
         validation_count: 1,
         evidence_count: 0,
@@ -417,7 +421,7 @@ describe("SQLite dashboard read model", () => {
           period_key: key,
           prd_count: 2,
           spec_count: 3,
-          task_count: 3,
+          task_count: 0, // All three Tasks in this fixture are draft, unlike their observed Runs.
           validation_count: 1,
           evidence_count: 1,
           total_run_count: 3,
@@ -451,17 +455,17 @@ describe("SQLite dashboard read model", () => {
       [
         "cost_monitor_daily",
         "2026-08-02",
-        { prd_count: 0, spec_count: 1, task_count: 1, validation_count: 1, evidence_count: 0 },
+        { prd_count: 0, spec_count: 1, task_count: 0, validation_count: 1, evidence_count: 0 },
       ],
       [
         "cost_monitor_monthly",
         "2026-08",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+        { prd_count: 2, spec_count: 3, task_count: 0, validation_count: 1, evidence_count: 1 },
       ],
       [
         "cost_monitor_annual",
         "2026",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+        { prd_count: 2, spec_count: 3, task_count: 0, validation_count: 1, evidence_count: 1 },
       ],
     ] as const) {
       expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
@@ -469,13 +473,13 @@ describe("SQLite dashboard read model", () => {
       );
     }
     expect(filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 1 }),
+      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 0 }),
     );
     expect(filesystem.viewPage("cost_monitor_monthly", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 3 }),
+      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 0 }),
     );
     expect(filesystem.viewPage("cost_monitor_annual", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 3 }),
+      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 0 }),
     );
     const annualCostPage = filesystem.viewPage("cost_monitor_annual", { limit: 50 });
     const dailyCostRows = filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows;
@@ -515,6 +519,21 @@ describe("SQLite dashboard read model", () => {
         observed.length === 0 ? null : observed.reduce((sum, value) => sum + value, 0),
       );
     }
+    const filteredFirst = filesystem.viewPage("cost_monitor_daily", {
+      limit: 1,
+      provider: "openai",
+    });
+    const filteredNext = filesystem.viewPage("cost_monitor_daily", {
+      limit: 1,
+      offset: 1,
+      provider: "openai",
+    });
+    expect(filteredFirst.totals).toEqual(filteredNext.totals);
+    expect(filteredFirst.period_averages).toEqual(filteredNext.period_averages);
+    expect(filteredFirst).toMatchObject({
+      totals: { task_count: 0, total_cost_brl: 15 },
+      period_averages: { BRL: { tasks: 0, tokens: 3, cost: 7.5 } },
+    });
     expect(
       filesystem.viewPage("cost_monitor_daily", { limit: 50, provider: "openai" }).rows,
     ).toContainEqual(
@@ -522,7 +541,7 @@ describe("SQLite dashboard read model", () => {
         key: "2026-08-02",
         prd_count: 0,
         spec_count: 1,
-        task_count: 1,
+        task_count: 0,
         validation_count: 1,
         evidence_count: 0,
       }),
@@ -635,6 +654,7 @@ describe("SQLite dashboard read model", () => {
     });
     expect(filesystem.firstFoldAllTime()).toBe(allTime);
     filesystem.close();
+    readers.delete(filesystem);
 
     // Period membership follows the canonical macro day, not an invocation
     // that happened on another day. Search accepts either the macro ID or
@@ -674,6 +694,7 @@ describe("SQLite dashboard read model", () => {
     );
     await rebuildSqliteReadModel(root);
     const canonicalDayFilesystem = new SqliteReadModelFileSystem(root);
+    readers.add(canonicalDayFilesystem);
     expect(
       canonicalDayFilesystem.viewPage("cost_monitor_specs", {
         from: "2026-08-03",
@@ -702,6 +723,7 @@ describe("SQLite dashboard read model", () => {
       }),
     ).toMatchObject({ total_count: 0, rows: [] });
     canonicalDayFilesystem.close();
+    readers.delete(canonicalDayFilesystem);
 
     // A large result set keeps its subtotal for all 270 matching Tasks while
     // the page transports only 50 records.
@@ -717,6 +739,7 @@ describe("SQLite dashboard read model", () => {
     }
     await rebuildSqliteReadModel(root);
     const pageFilesystem = new SqliteReadModelFileSystem(root);
+    readers.add(pageFilesystem);
     const paged = pageFilesystem.viewPage("cost_monitor_tasks", {
       from: "2026-08-04",
       to: "2026-08-04",
@@ -735,5 +758,6 @@ describe("SQLite dashboard read model", () => {
       total_cost_brl: 1_350,
     });
     pageFilesystem.close();
+    readers.delete(pageFilesystem);
   });
 });

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

@@ -344,14 +344,28 @@ export class SqliteReadModelFileSystem extends WorkspaceFileSystem {
     return queryTopTasks(this.queryContext(), filter, limit);
   }
 
-  canonicalTraceFiles(markers: readonly string[]): Array<{ path: string; content: string }> {
+  canonicalTraceFiles(
+    markers: readonly string[],
+    maxContentLength?: number,
+  ): Array<{ path: string; content: string }> {
     const selected = [...new Set(markers.filter(Boolean))];
     if (selected.length === 0) return [];
+    if (
+      maxContentLength !== undefined &&
+      (!Number.isSafeInteger(maxContentLength) || maxContentLength < 0)
+    )
+      throw new Error("Invalid trace content bound");
     const clauses = selected.map(() => "content LIKE ?").join(" OR ");
+    // SQL counts code points while the caller retains its UTF-16 length check.
+    // This conservative prefilter never excludes an otherwise admissible file.
+    const bound = maxContentLength === undefined ? "" : " AND length(content) <= ?";
     return this.database
       .prepare(`SELECT path, content FROM files
-        WHERE (path LIKE '.agents/data/%' OR path LIKE '.agents/records/%') AND (${clauses}) ORDER BY path`)
-      .all(...selected.map((marker) => `%${marker}%`)) as Array<{
+        WHERE (path LIKE '.agents/data/%' OR path LIKE '.agents/records/%')${bound} AND (${clauses}) ORDER BY path`)
+      .all(
+        ...(maxContentLength === undefined ? [] : [maxContentLength]),
+        ...selected.map((marker) => `%${marker}%`),
+      ) as Array<{
       path: string;
       content: string;
     }>;

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

@@ -210,7 +210,7 @@ describe("SQLite dashboard read model", () => {
         snapshot
           .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
           .get(),
-      ).toEqual({ value: "74" });
+      ).toEqual({ value: "78" });
     } finally {
       snapshot.close();
     }

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

@@ -596,6 +596,7 @@ export async function rebuildSqliteReadModel(
             () => [...readCanonicalEntities([row])],
           ))
             if (entity.creationRunId) changedCreationRunIds.add(entity.creationRunId);
+      reportLaunchProgress("projection_entities", 75, "Entidades canônicas interpretadas.");
       const insertCanonicalWorkItem = database.prepare(
         "INSERT INTO canonical_work_items(entity_kind, id, title, status, stage, risk, spec_id, change_id, creation_run_id, completed_run_id, occurred_at, occurred_day_sp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
       );
@@ -645,6 +646,7 @@ export async function rebuildSqliteReadModel(
       canonicalLifecycle.decisions = [
         ...new Map(canonicalLifecycle.decisions.map((item) => [item.id, item])).values(),
       ];
+      reportLaunchProgress("projection_lifecycle", 76, "Registros de ciclo de vida interpretados.");
       const insertCanonicalExecution = database.prepare(
         "INSERT INTO canonical_executions(id, status, kind, origin_type, origin_id, created_at, occurred_day_sp, finished_at, source_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
       );
@@ -695,6 +697,7 @@ export async function rebuildSqliteReadModel(
           saoPauloDay(entity.createdAt),
           entity.sourcePath,
         );
+      reportLaunchProgress("projection_runs_started", 77, "Construindo fatos das invocações.");
       const runMaterialization = materializeCanonicalRuns({
         database,
         previousActivities,
@@ -712,6 +715,11 @@ export async function rebuildSqliteReadModel(
       // Run canonical and attach deterministic shares only to the macro read
       // model. Payload rows stay outside `activities`, preventing global
       // Run/Cost totals from counting that Run more than once.
+      reportLaunchProgress(
+        "projection_dimensions_started",
+        78,
+        "Construindo dimensões e agregados.",
+      );
       materializeDashboardProjections({
         ...runMaterialization,
         database,
@@ -722,6 +730,7 @@ export async function rebuildSqliteReadModel(
         skipped,
         fingerprint,
       });
+      reportLaunchProgress("projection_overview_started", 79, "Construindo a visão geral.");
       refreshFirstFoldPayloads(workspaceRoot, database);
       database.exec("COMMIT;");
       reportLaunchProgress(

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

@@ -4,10 +4,9 @@ import { DatabaseSync } from "node:sqlite";
 import { hasRequiredFirstFoldPayloads } from "./sqlite-first-fold-persistence.js";
 import type { SqliteReadModelSourceCheckpoint } from "./sqlite-read-model-source-fingerprint.js";
 export const dbRelativePath = ".local/sqlite/zaip-aios-dashboard.sqlite";
-// Schema 75 adds the persisted latest positive-token collection timestamp.
-// A schema rebuild is required even when source hashes match so an older
-// snapshot cannot masquerade as a telemetry-fresh projection.
-export const readModelSchemaVersion = "75";
+// Schema 78 aligns usage-segment providers with canonical activity providers.
+// Old snapshots must rebuild even when their canonical hashes still match.
+export const readModelSchemaVersion = "78";
 export const requiredPersistedTables = [
   "zaip_aios_activities",
   "zaip_dim_llm_model",
@@ -32,6 +31,7 @@ export const requiredIndexes = [
   "zaip_activities_period_invocation",
   "zaip_activities_status",
   "zaip_activities_payload",
+  "zaip_activities_file_path",
   "zaip_activities_work_item_identity",
   "cost_dimension_facts_day_model",
   "cost_dimension_facts_day_provider",