@zaip-ai/cli 4.5.0 → 4.7.0

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

@@ -0,0 +1,163 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { prepareDashboardSqliteStartup } from "./sqlite-dashboard-startup.js";
+import { rebuildSqliteReadModel } from "./sqlite-read-model-rebuild.js";
+import { sqliteReadModelPath, validateSqliteReadModelSchema } from "./sqlite-read-model-schema.js";
+import { sourceFingerprint } from "./sqlite-read-model-source-fingerprint.js";
+
+vi.mock("./sqlite-read-model-source-fingerprint.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./sqlite-read-model-source-fingerprint.js")>();
+  return { ...actual, sourceFingerprint: vi.fn(actual.sourceFingerprint) };
+});
+
+const roots: string[] = [];
+const taskContent = (title: string) =>
+  `---\nid: TASK-STARTUP\ntitle: ${title}\nstatus: ready\nrisk: standard\ncreated_at: 2026-08-01T12:00:00.000Z\n---\n`;
+
+async function fixture(seed = true) {
+  vi.stubEnv("ZAIP_SQLITE_DB_PATH", undefined);
+  const fixtures = resolve(import.meta.dirname, "../../../../../.local/sqlite/tests");
+  await mkdir(fixtures, { recursive: true });
+  const root = await mkdtemp(resolve(fixtures, "startup-"));
+  roots.push(root);
+  const task = resolve(root, ".agents/records/tasks/task.md");
+  await mkdir(dirname(task), { recursive: true });
+  await mkdir(resolve(root, ".agents/config"), { recursive: true });
+  await writeFile(resolve(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+  await writeFile(task, taskContent("Original seed"));
+  if (seed) await rebuildSqliteReadModel(root);
+  vi.mocked(sourceFingerprint).mockClear();
+  return { root, task, path: sqliteReadModelPath(root) };
+}
+
+function editDatabase(path: string, sql: string) {
+  const database = new DatabaseSync(path);
+  try {
+    database.exec(sql);
+  } finally {
+    database.close();
+  }
+}
+
+function persistedTask(path: string): string {
+  const database = new DatabaseSync(path, { readOnly: true });
+  try {
+    return (
+      database
+        .prepare("SELECT content FROM zaip_vw_files WHERE path=?")
+        .get(".agents/records/tasks/task.md") as { content: string }
+    ).content;
+  } finally {
+    database.close();
+  }
+}
+
+afterEach(async () => {
+  vi.unstubAllEnvs();
+  vi.mocked(sourceFingerprint).mockClear();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("dashboard SQLite startup", () => {
+  it("serves a validated stale seed without source inventory even after canonical changes", async () => {
+    const { root, task, path } = await fixture();
+    await writeFile(task, taskContent("Changed canonically"));
+    const before = await readFile(path);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      await expect(prepareDashboardSqliteStartup(root)).resolves.toMatchObject({
+        path,
+        files: 2,
+        cache: "stale_seed",
+        fingerprint_ms: 0,
+        materialize_ms: 0,
+        refresh: { processed_sources: 0, reused_sources: 0, canonical_runs_refolded: 0 },
+      });
+    }
+    expect(sourceFingerprint).not.toHaveBeenCalled();
+    expect(await readFile(path)).toEqual(before);
+    expect(persistedTask(path)).toContain("Original seed");
+    // The normal refresh remains canonical and publishes the changed source.
+    await rebuildSqliteReadModel(root);
+    expect(sourceFingerprint).toHaveBeenCalled();
+    expect(persistedTask(path)).toContain("Changed canonically");
+  });
+
+  it.each([
+    [
+      "schema",
+      "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json,'$.value','old') WHERE payload_type='metadata' AND json_extract(payload_json,'$.key')='schema_version'",
+    ],
+    ["index", "DROP INDEX zaip_activities_work_item_identity"],
+    [
+      "missing first fold",
+      "DELETE FROM zaip_aios_activities WHERE payload_type='first_fold_all_time_cache'",
+    ],
+    [
+      "truncated board",
+      "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json,'$.pages.task',json('[]')) WHERE payload_type='first_fold_all_time_board_cache'",
+    ],
+    [
+      "malformed board",
+      "UPDATE zaip_aios_activities SET payload_json='invalid' WHERE payload_type='first_fold_all_time_board_cache'",
+    ],
+    [
+      "malformed cost summary",
+      "UPDATE zaip_aios_activities SET payload_json='invalid' WHERE payload_type='cost_monitor_summary_cache'",
+    ],
+    [
+      "invalid file count",
+      "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json,'$.value','NaN') WHERE payload_type='metadata' AND json_extract(payload_json,'$.key')='source_file_count'",
+    ],
+  ])("rejects %s and rebuilds changed canonical sources", async (_damage, sql) => {
+    const { root, task, path } = await fixture();
+    editDatabase(path, sql);
+    await writeFile(task, taskContent("Recovered canonical source"));
+    await expect(prepareDashboardSqliteStartup(root)).resolves.toMatchObject({
+      path,
+      cache: "rebuilt",
+    });
+    expect(sourceFingerprint).toHaveBeenCalled();
+    expect(() => validateSqliteReadModelSchema(path)).not.toThrow();
+    expect(persistedTask(path)).toContain("Recovered canonical source");
+  });
+
+  it("builds canonical data when the seed is absent", async () => {
+    const { root, path } = await fixture(false);
+    await expect(prepareDashboardSqliteStartup(root)).resolves.toMatchObject({
+      path,
+      cache: "rebuilt",
+    });
+    expect(sourceFingerprint).toHaveBeenCalled();
+    expect(() => validateSqliteReadModelSchema(path)).not.toThrow();
+  });
+
+  it("accepts a genuinely empty committed model without fabricating source work", async () => {
+    const { root, task, path } = await fixture(false);
+    await rm(task);
+    await rm(resolve(root, ".agents/config/project.yaml"));
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 0 });
+    vi.mocked(sourceFingerprint).mockClear();
+    await expect(prepareDashboardSqliteStartup(root)).resolves.toMatchObject({
+      path,
+      files: 0,
+      cache: "stale_seed",
+      fingerprint_ms: 0,
+    });
+    expect(sourceFingerprint).not.toHaveBeenCalled();
+  });
+
+  it("honors an explicit forced canonical rebuild", async () => {
+    const { root, task, path } = await fixture();
+    await writeFile(task, taskContent("Forced canonical source"));
+    await expect(
+      prepareDashboardSqliteStartup(root, { forceCanonical: true }),
+    ).resolves.toMatchObject({
+      path,
+      cache: "rebuilt",
+    });
+    expect(sourceFingerprint).toHaveBeenCalled();
+    expect(persistedTask(path)).toContain("Forced canonical source");
+  });
+});

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

@@ -0,0 +1,78 @@
+import { DatabaseSync } from "node:sqlite";
+import { rebuildSqliteReadModel } from "./sqlite-read-model-rebuild.js";
+import {
+  hasReusableSnapshotPayloads,
+  sqliteReadModelPath,
+  validateSqliteReadModelSchema,
+} from "./sqlite-read-model-schema.js";
+import type { SqliteRebuildOptions } from "./sqlite-rebuild-fingerprint-options.js";
+import type { SqliteRebuildResult } from "./sqlite-rebuild-result.js";
+
+export type SqliteDashboardStartupOptions = Pick<
+  SqliteRebuildOptions,
+  "forceCanonical" | "sourceRoots"
+>;
+
+function hasReadableFirstFoldPayloads(database: DatabaseSync): boolean {
+  const rows = database
+    .prepare(`SELECT payload_json FROM zaip_aios_activities
+    WHERE payload_type IN ('first_fold_viewport_cache', 'first_fold_all_time_cache',
+      'first_fold_all_time_board_cache', 'cost_monitor_summary_cache',
+      'cost_monitor_summary_month_cache', 'first_fold_monthly_quick_cache')`)
+    .all() as Array<{ payload_json: string }>;
+  return rows.every(({ payload_json }) => {
+    const payload: unknown = JSON.parse(payload_json);
+    return payload !== null && typeof payload === "object" && !Array.isArray(payload);
+  });
+}
+
+/**
+ * Startup validates only the committed database. Canonical source discovery
+ * belongs to the asynchronous refresh after the server starts listening.
+ * Even an unchanged seed is stale until that refresh proves its freshness.
+ */
+export async function prepareDashboardSqliteStartup(
+  workspaceRoot: string,
+  options: SqliteDashboardStartupOptions = {},
+): Promise<SqliteRebuildResult> {
+  const path = sqliteReadModelPath(workspaceRoot);
+  if (!options.forceCanonical) {
+    try {
+      validateSqliteReadModelSchema(path);
+      const database = new DatabaseSync(path, { readOnly: true });
+      try {
+        if (hasReusableSnapshotPayloads(database) && hasReadableFirstFoldPayloads(database)) {
+          const row = database
+            .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='source_file_count'")
+            .get() as { value?: unknown } | undefined;
+          const files =
+            typeof row?.value === "string" && /^\d+$/.test(row.value)
+              ? Number(row.value)
+              : Number.NaN;
+          if (Number.isSafeInteger(files) && files >= 0) {
+            return {
+              files,
+              path,
+              cache: "stale_seed",
+              fingerprint_ms: 0,
+              materialize_ms: 0,
+              refresh: {
+                reused_sources: 0,
+                processed_sources: 0,
+                added_sources: 0,
+                changed_sources: 0,
+                removed_sources: 0,
+                canonical_runs_refolded: 0,
+              },
+            };
+          }
+        }
+      } finally {
+        database.close();
+      }
+    } catch {
+      // Missing, damaged, incompatible or incomplete databases are never served.
+    }
+  }
+  return rebuildSqliteReadModel(workspaceRoot, { ...options, preferExisting: false });
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-header-timestamp.test.ts

@@ -0,0 +1,31 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { expect, it } from "vitest";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+it("status-only reconciliation promotes the snapshot without faking a new token collection time", async () => {
+  const base = resolve(import.meta.dirname, "../../../../../../.tmp/dashboard-header-time");
+  await mkdir(base, { recursive: true });
+  const root = await mkdtemp(join(base, "fixture-"));
+  let filesystem: SqliteReadModelFileSystem | undefined;
+  try {
+    await prepareMultiProviderFixture(root);
+    await rebuildSqliteReadModel(root);
+    filesystem = new SqliteReadModelFileSystem(root);
+    const collected = filesystem.latestTokenCollectedAt();
+    const snapshot = filesystem.projectionUpdatedAt();
+    expect(collected).toBe("2026-08-04T16:00:01.000Z");
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await writeFile(
+      join(root, ".agents/records/tasks/TASK-STATUS.md"),
+      "---\nschema_version: 2\nid: TASK-STATUS\ntitle: Status only\nstatus: blocked\ncreated_at: 2026-09-29T10:00:00Z\n---\n# Status\n",
+    );
+    await filesystem.rebuildAndRefresh(() => rebuildSqliteReadModel(root));
+    expect(filesystem.latestTokenCollectedAt()).toBe(collected);
+    expect(filesystem.projectionUpdatedAt()).not.toBe(snapshot);
+  } finally {
+    filesystem?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,271 @@
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { hasVisibleProviderMetrics, providerVisibleMetrics } from "./sqlite-provider-visibility.js";
+import { readCachedCostViewPage } from "./sqlite-query-cached-cost-page.js";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+import { queryUncachedViewPage } from "./sqlite-query-view-page.js";
+
+const databases: DatabaseSync[] = [];
+afterEach(() => {
+  while (databases.length) databases.pop()?.close();
+});
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  databases.push(database);
+  database.exec(`
+    CREATE TABLE invocations (
+      agent_invocation_id TEXT, task_id TEXT, duration_ms REAL, source_event_count REAL,
+      input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL,
+      total_tokens REAL, cost_usd REAL, cost_brl REAL, source_started_at TEXT,
+      source_occurred_at TEXT, occurred_at TEXT, zaip_agent TEXT, phase TEXT,
+      status TEXT, work_type TEXT, prd_id TEXT, spec_id TEXT
+    );
+    CREATE TABLE tasks (id TEXT, status TEXT, priority TEXT, risk TEXT);
+    CREATE TABLE cost_invocation_dimension_facts (
+      agent_invocation_id TEXT, provider TEXT, model TEXT, input_tokens REAL,
+      cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL,
+      total_tokens REAL, cost_usd REAL, cost_brl REAL, occurred_day_sp TEXT
+    );
+    CREATE TABLE zaip_aios_activities (
+      payload_type TEXT, payload_json TEXT, activity_source_kind TEXT,
+      agent_invocation_id TEXT, task_id TEXT, duration_ms REAL, source_event_count REAL,
+      input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL,
+      total_tokens REAL, cost_usd REAL, cost_brl REAL, occurred_day_sp TEXT
+    );
+  `);
+  const context = {
+    database,
+    technicalPayloadRows: () => [],
+  } as unknown as SqliteQueryContext;
+  const payload = (row: Record<string, unknown>) =>
+    database
+      .prepare("INSERT INTO zaip_aios_activities(payload_type,payload_json) VALUES (?,?)")
+      .run("cost_dimension_aggregate_v1", JSON.stringify({ dimension: "provider", ...row }));
+  const invocation = (id: string, tokens: number, duration: number | null = null) => {
+    database
+      .prepare(`INSERT INTO invocations
+      (agent_invocation_id,total_tokens,cost_usd,cost_brl,duration_ms,source_event_count,
+       source_started_at,phase) VALUES (?,?,0,0,?,9,'2026-09-29T12:00:00Z','execution')`)
+      .run(id, tokens, duration);
+    database
+      .prepare(`INSERT INTO zaip_aios_activities
+      (activity_source_kind,agent_invocation_id,total_tokens,cost_usd,cost_brl,
+       duration_ms,source_event_count,occurred_day_sp) VALUES ('agent_run',?,?,0,0,?,9,'2026-09-29')`)
+      .run(id, tokens, duration);
+  };
+  const segment = (id: string, provider: string | null, tokens: number) =>
+    database
+      .prepare(`INSERT INTO cost_invocation_dimension_facts
+      (agent_invocation_id,provider,model,total_tokens,cost_usd,cost_brl,occurred_day_sp)
+      VALUES (?,?,'model',?,0,0,'2026-09-29')`)
+      .run(id, provider, tokens);
+  return { database, context, payload, invocation, segment };
+}
+
+const empty = {
+  invocation_count: 0,
+  task_count: 0,
+  total_duration: null,
+  total_tokens: 0,
+  total_cost_usd: 0,
+  total_cost_brl: null,
+};
+
+describe("provider visibility", () => {
+  it.each(
+    providerVisibleMetrics,
+  )("retains activity in %s independently of cost or invocation", (field) => {
+    const { context, payload } = fixture();
+    payload({ key: "unavailable", ...empty });
+    payload({ key: "active", ...empty, [field]: 1 });
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", {});
+    expect(page.rows.map((row) => row.key)).toEqual(["active"]);
+    expect(page.total_count).toBe(1);
+    expect(page.rows[0]?.[field]).toBe(1);
+  });
+
+  it("ignores unavailable/zero metrics and hidden metrics, retaining negative adjustments", () => {
+    expect(hasVisibleProviderMetrics({ ...empty, source_event_count: 9 })).toBe(false);
+    expect(hasVisibleProviderMetrics({})).toBe(false);
+    expect(hasVisibleProviderMetrics({ ...empty, total_cost_usd: -1 })).toBe(true);
+    expect(hasVisibleProviderMetrics({ ...empty, total_cost_usd: 0.0049 })).toBe(false);
+    expect(hasVisibleProviderMetrics({ ...empty, total_cost_usd: 0.005 })).toBe(true);
+    expect(hasVisibleProviderMetrics({ ...empty, total_cost_brl: -0.005 })).toBe(true);
+  });
+
+  it("hides sub-cent residual costs from payload while preserving raw financial totals", () => {
+    const { context, payload } = fixture();
+    const residual = {
+      total_cost_usd: 0.00004640000001435857,
+      total_cost_brl: 0.000010780000006496704,
+    };
+    payload({ key: "unavailable", ...empty, ...residual });
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", {});
+    expect(page).toMatchObject({ total_count: 0, rows: [], has_more: false });
+    expect(page.totals).toMatchObject(residual);
+  });
+
+  it.each([
+    { phase: "execution" },
+    { from: "2026-09-29" },
+  ])("hides SQL residual-cost-only rows at displayed precision: %j", (input) => {
+    const { context, invocation, segment, database } = fixture();
+    invocation("residual", 0);
+    segment("residual", null, 0);
+    database.exec(`
+      UPDATE invocations SET cost_usd=0.00004640000001435857,cost_brl=0.000010780000006496704;
+      UPDATE zaip_aios_activities SET cost_usd=0.00004640000001435857,cost_brl=0.000010780000006496704;
+      UPDATE cost_invocation_dimension_facts SET cost_usd=0.00004640000001435857,cost_brl=0.000010780000006496704;
+    `);
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", input);
+    expect(page).toMatchObject({ total_count: 0, rows: [], has_more: false });
+    expect(page.totals).toMatchObject({
+      total_cost_usd: 0.00004640000001435857,
+      total_cost_brl: 0.000010780000006496704,
+    });
+  });
+
+  it("filters payload before pagination without changing factual totals or null coverage", () => {
+    const { context, payload } = fixture();
+    payload({ key: "unavailable", ...empty, source_event_count: 9 });
+    payload({ key: "known-empty", ...empty });
+    payload({ key: "active", ...empty, total_tokens: 7 });
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", { limit: 1 });
+    expect(page).toMatchObject({ total_count: 1, has_more: false });
+    expect(page.rows).toEqual([
+      expect.objectContaining({ key: "active", total_duration: null, total_cost_brl: null }),
+    ]);
+    expect(page.totals).toMatchObject({
+      total_tokens: 7,
+      total_cost_usd: 0,
+      total_cost_brl: null,
+      total_duration: null,
+      source_event_count: 9,
+    });
+    const next = queryUncachedViewPage(context, "cost_monitor_providers", { limit: 1, offset: 1 });
+    expect(next).toMatchObject({ total_count: 1, rows: [], has_more: false });
+  });
+
+  it("retains genuine unattributed payload activity and returns a coherent empty page", () => {
+    const { context, payload } = fixture();
+    payload({ key: "unavailable", ...empty });
+    expect(queryUncachedViewPage(context, "cost_monitor_providers", {})).toMatchObject({
+      total_count: 0,
+      rows: [],
+      has_more: false,
+    });
+    payload({ key: null, ...empty, total_tokens: 3 });
+    expect(queryUncachedViewPage(context, "cost_monitor_providers", {}).rows).toEqual([
+      expect.objectContaining({ key: null, total_tokens: 3 }),
+    ]);
+    expect(readCachedCostViewPage(context, "cost_monitor_providers", {})).toBeNull();
+  });
+
+  it.each([
+    { phase: "execution" },
+    { from: "2026-09-29", to: "2026-09-29" },
+  ])("filters SQL before count and paging for %j while retaining factual populations", (input) => {
+    const { context, invocation, segment, database } = fixture();
+    invocation("mixed", 10, 100);
+    segment("mixed", "openai", 10);
+    segment("mixed", "empty-known", 0);
+    segment("mixed", null, 0);
+    invocation("unattributed", 7);
+    segment("unattributed", null, 7);
+    invocation("free", 0);
+    segment("free", "free-provider", 0);
+    const factsBefore = database.prepare("SELECT * FROM cost_invocation_dimension_facts").all();
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", { ...input, limit: 2 });
+    expect(page).toMatchObject({ total_count: 3, has_more: true });
+    expect(page.rows.map((row) => row.key)).toEqual(["free-provider", "openai"]);
+    expect(page.rows[0]).toMatchObject({ invocation_count: 1, total_tokens: 0, total_cost_usd: 0 });
+    expect(page.rows[1]).toMatchObject({
+      invocation_count: 0,
+      total_tokens: 10,
+      total_cost_brl: 0,
+      total_duration: null,
+    });
+    expect(page.totals).toMatchObject({
+      invocation_count: 3,
+      total_tokens: 17,
+      total_duration: 100,
+      total_cost_usd: 0,
+      source_event_count: 27,
+    });
+    const next = queryUncachedViewPage(context, "cost_monitor_providers", {
+      ...input,
+      limit: 2,
+      offset: 2,
+    });
+    expect(next).toMatchObject({ total_count: 3, has_more: false });
+    expect(next.rows).toEqual([
+      expect.objectContaining({ key: "unavailable", invocation_count: 0, total_tokens: 7 }),
+    ]);
+    expect(next.totals).toEqual(page.totals);
+    expect(database.prepare("SELECT * FROM cost_invocation_dimension_facts").all()).toEqual(
+      factsBefore,
+    );
+  });
+
+  it.each([
+    { phase: "execution" },
+    { from: "2026-09-29" },
+  ])("returns empty SQL page for only zero/null rows: %j", (input) => {
+    const { context, invocation, segment } = fixture();
+    invocation("zero", 0);
+    segment("zero", null, 0);
+    expect(queryUncachedViewPage(context, "cost_monitor_providers", input)).toMatchObject({
+      total_count: 0,
+      rows: [],
+      has_more: false,
+      totals: { invocation_count: 1, total_tokens: 0, total_cost_usd: 0 },
+    });
+  });
+
+  it.each([
+    { phase: "execution" },
+    { from: "2026-09-29" },
+  ])("retains zero-cost task-only and meaningful unattributed cost in SQL: %j", (input) => {
+    const { context, invocation, segment, database } = fixture();
+    invocation("task-only", 0);
+    segment("task-only", "provider-a", 0);
+    segment("task-only", "provider-b", 0);
+    database.exec(
+      "UPDATE invocations SET task_id='TASK-1'; UPDATE zaip_aios_activities SET task_id='TASK-1'",
+    );
+    invocation("cost-only", 0);
+    segment("cost-only", null, 0);
+    database.exec(`
+      UPDATE invocations SET cost_usd=0.005 WHERE agent_invocation_id='cost-only';
+      UPDATE zaip_aios_activities SET cost_usd=0.005 WHERE agent_invocation_id='cost-only';
+      UPDATE cost_invocation_dimension_facts SET cost_usd=0.005 WHERE agent_invocation_id='cost-only';
+    `);
+    const page = queryUncachedViewPage(context, "cost_monitor_providers", input);
+    expect(page.total_count).toBe(3);
+    expect(page.rows).toEqual([
+      expect.objectContaining({
+        key: "provider-a",
+        invocation_count: 0,
+        task_count: 1,
+        total_tokens: 0,
+        total_cost_usd: 0,
+      }),
+      expect.objectContaining({
+        key: "provider-b",
+        invocation_count: 0,
+        task_count: 1,
+        total_tokens: 0,
+        total_cost_usd: 0,
+      }),
+      expect.objectContaining({
+        key: "unavailable",
+        invocation_count: 0,
+        task_count: 0,
+        total_tokens: 0,
+        total_cost_usd: 0.005,
+      }),
+    ]);
+    expect(page.totals).toMatchObject({ task_count: 1, total_cost_usd: 0.005 });
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-provider-visibility.ts

@@ -0,0 +1,32 @@
+/** Only metrics displayed in Provedores determine whether a row has activity. */
+export const providerVisibleMetrics = [
+  "invocation_count",
+  "task_count",
+  "total_duration",
+  "total_tokens",
+  "total_cost_usd",
+  "total_cost_brl",
+] as const;
+
+// Costs are displayed with two decimal places; sub-cent reconciliation
+// remainders remain factual totals but do not constitute visible activity.
+const minimumVisibleCost = 0.005;
+
+export function hasVisibleProviderMetrics(row: Record<string, unknown>): boolean {
+  return providerVisibleMetrics.some(
+    (field) =>
+      typeof row[field] === "number" &&
+      (field === "total_cost_usd" || field === "total_cost_brl"
+        ? Math.abs(row[field]) >= minimumVisibleCost
+        : row[field] !== 0),
+  );
+}
+
+/** Applied to aggregated rows, before COUNT, LIMIT and OFFSET. */
+export const providerVisibleMetricsSql = providerVisibleMetrics
+  .map((field) =>
+    field === "total_cost_usd" || field === "total_cost_brl"
+      ? `ABS(COALESCE(${field}, 0)) >= ${minimumVisibleCost}`
+      : `COALESCE(${field}, 0) <> 0`,
+  )
+  .join(" OR ");

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

@@ -0,0 +1,58 @@
+import type { SqliteViewPageInput } from "./sqlite-query-cached-cost-page.js";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+
+/** Recompose coarse period rows from daily facts when a date range cuts through them. */
+export function attachOperationsDuration(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewPageInput,
+  rows: Array<Record<string, unknown>>,
+): void {
+  if (!["operations_daily", "operations_monthly", "operations_annual"].includes(view)) return;
+  const partialCoarse = view !== "operations_daily" && (input.from || input.to);
+  const partialFromDay = input.from?.slice(0, 10) ?? null;
+  const partialToDay = input.to?.slice(0, 10) ?? null;
+  const dailyRows = partialCoarse
+    ? (context.database
+        .prepare(
+          `SELECT * FROM operations_daily WHERE (? IS NULL OR day >= ?) AND (? IS NULL OR day <= ?)`,
+        )
+        .all(partialFromDay, partialFromDay, partialToDay, partialToDay) as Array<
+        Record<string, unknown>
+      >)
+    : [];
+  const daily = context.executionDurationByDay({
+    from: input.from ?? null,
+    to: input.to ?? null,
+  });
+  for (const row of rows) {
+    const key = String(row.day ?? row.period_key);
+    if (partialCoarse) {
+      const matching = dailyRows.filter((day) => String(day.day).startsWith(key));
+      const matchingDays = matching.map((day) => String(day.day)).sort();
+      row.start_day = matchingDays[0] ?? null;
+      row.end_day = matchingDays.at(-1) ?? null;
+      for (const column of [
+        "prd_count",
+        "spec_count",
+        "task_count",
+        "validation_count",
+        "evidence_count",
+        "total_run_count",
+        "invocation_count",
+        "llm_call_count",
+        "total_tokens",
+        "total_cost_usd",
+        "total_cost_brl",
+      ] as const)
+        row[column] = matching.reduce(
+          (sum, day) => sum + (typeof day[column] === "number" ? Number(day[column]) : 0),
+          0,
+        );
+    }
+    row.operations_total_duration = [...daily]
+      .filter(([day]) => (view === "operations_daily" ? day === key : day.startsWith(key)))
+      .reduce((sum, [, duration]) => sum + duration, 0);
+  }
+}

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

@@ -1,4 +1,5 @@
 import { costDimensionFactDateFilter } from "./sqlite-cost-agent-page.js";
+import { providerVisibleMetricsSql } from "./sqlite-provider-visibility.js";
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
 export function readProviderDimension(
@@ -131,13 +132,21 @@ export function readProviderDimension(
       ), task_population AS (
         SELECT provider_key AS key, COUNT(*) AS task_count
         FROM task_providers GROUP BY provider_key
-      ), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population)`;
+      ), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population),
+      aggregated_rows AS (
+        SELECT keys.key, keys.key AS label, COALESCE(population.invocation_count,0) AS invocation_count,
+          COALESCE(task_population.task_count,0) AS task_count, population.total_duration,
+          population.source_event_count, financial.total_tokens, financial.total_cost_usd,
+          financial.total_cost_brl
+        FROM keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key)
+          LEFT JOIN financial USING(key)
+      ), visible_rows AS (SELECT * FROM aggregated_rows WHERE ${providerVisibleMetricsSql})`;
   const limit = Math.min(200, Math.max(1, input.limit ?? 50));
   const offset = Math.max(0, input.offset ?? 0);
   const total_count = Number(
     (
       context.database
-        .prepare(`${ctes} ${facts} SELECT COUNT(*) AS count FROM keys`)
+        .prepare(`${ctes} ${facts} SELECT COUNT(*) AS count FROM visible_rows`)
         .get(...values) as { count: number }
     ).count,
   );
@@ -160,7 +169,7 @@ export function readProviderDimension(
     .get(...values) as Record<string, unknown>;
   const rows = context.database
     .prepare(
-      `${ctes} ${facts} SELECT keys.key, keys.key AS label, COALESCE(population.invocation_count,0) AS invocation_count, COALESCE(task_population.task_count,0) AS task_count, population.total_duration, population.source_event_count, financial.total_tokens, financial.total_cost_usd, financial.total_cost_brl FROM keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key) LEFT JOIN financial USING(key) ORDER BY financial.total_cost_brl DESC, keys.key LIMIT ? OFFSET ?`,
+      `${ctes} ${facts} SELECT * FROM visible_rows ORDER BY total_cost_brl DESC, key LIMIT ? OFFSET ?`,
     )
     .all(...values, limit, offset) as Array<Record<string, unknown>>;
   return {