@zaip-ai/cli 4.5.0 → 4.6.0

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 {

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

@@ -4,6 +4,7 @@ import {
   operationsWorkListPayloadPage,
   operationsWorkListSqlPage,
 } from "./sqlite-operations-work-list.js";
+import { hasVisibleProviderMetrics } from "./sqlite-provider-visibility.js";
 import { readAgentDimension } from "./sqlite-query-agent-dimension.js";
 import {
   readCachedCostViewPage,
@@ -13,6 +14,7 @@ import type { SqliteQueryContext, SqliteViewPage } from "./sqlite-query-context.
 import { readEntityGroup } from "./sqlite-query-entity-group.js";
 import { readFilteredDimension } from "./sqlite-query-filtered-dimension.js";
 import { readModelDimension } from "./sqlite-query-model-dimension.js";
+import { attachOperationsDuration } from "./sqlite-query-operations-duration.js";
 import { readProviderDimension } from "./sqlite-query-provider-dimension.js";
 import { readTemporalDimension } from "./sqlite-query-temporal-dimension.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
@@ -239,7 +241,7 @@ export function queryUncachedViewPage(
     const visiblePayloadRows =
       dimension === "model"
         ? payloadRows.filter((row) => row.key !== "unavailable" && row.key !== null)
-        : payloadRows;
+        : payloadRows.filter(hasVisibleProviderMetrics);
     const limit = Math.min(200, Math.max(1, input.limit ?? 50));
     const offset = Math.max(0, input.offset ?? 0);
     const rows = visiblePayloadRows.slice(offset, offset + limit);
@@ -268,9 +270,11 @@ export function queryUncachedViewPage(
         for (const field of modelNumericFields)
           row[field] = typeof row[field] === "number" ? row[field] : 0;
     }
+    // Provider visibility must not change factual totals or known-zero coverage.
+    const totalRows = dimension === "provider" ? payloadRows : visiblePayloadRows;
     const nullableSum = (field: string) =>
-      visiblePayloadRows.some((row) => typeof row[field] === "number")
-        ? visiblePayloadRows.reduce(
+      totalRows.some((row) => typeof row[field] === "number")
+        ? totalRows.reduce(
             (sum, row) => sum + (typeof row[field] === "number" ? Number(row[field]) : 0),
             0,
           )
@@ -284,7 +288,7 @@ export function queryUncachedViewPage(
         total_count: visiblePayloadRows.length,
         has_more: offset + rows.length < visiblePayloadRows.length,
         totals: {
-          invocation_count: visiblePayloadRows.reduce(
+          invocation_count: totalRows.reduce(
             (sum, row) => sum + Number(row.invocation_count ?? 0),
             0,
           ),
@@ -490,60 +494,7 @@ export function queryUncachedViewPage(
   const rows = context.database
     .prepare(`SELECT * FROM ${view}${where} ORDER BY ${meta.order} LIMIT ? OFFSET ?`)
     .all(...values, limit, offset) as Array<Record<string, unknown>>;
-  if (
-    view === "operations_daily" ||
-    view === "operations_monthly" ||
-    view === "operations_annual"
-  ) {
-    // A partial date interval intersects a coarse month/year row but does
-    // not make its all-time additive metrics applicable. Recompose it from
-    // the same daily facts used by Operations cards.
-    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);
-    }
-  }
+  attachOperationsDuration(context, view, input, rows);
   return {
     data_source: "sqlite_read_model" as const,
     view,