@zaip-ai/cli 1.3.0 → 1.3.2

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

@@ -1,7 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { loadWorkspaceLayout, WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
@@ -18,17 +17,11 @@ import {
   readSpecDetail,
   readTaskDetail,
 } from "@zaip-ai/dashboard-operations/server";
-import {
-  buildTaskTrace,
-  buildTraceStageRecords,
-  classifyTraceDocument,
-  timestampsFromContent,
-} from "@zaip-ai/dashboard-traceability/server";
-import { type CompactRunMetric, LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import { buildTaskTrace } from "@zaip-ai/dashboard-traceability/server";
+import { LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
 import { type Context, Hono } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { TaskTrace, TraceDocument } from "../../../modules/traceability/src/contracts.js";
 import { runAgentAdapterSync } from "./agent-adapter-sync.js";
 import {
   type AgentAdapterSyncResult,
@@ -57,21 +50,28 @@ import {
 } from "./server-operations-pages.js";
 import { registerOperationsRunsRoute } from "./server-operations-runs-route.js";
 import { projectionPeriodFilter } from "./server-period.js";
+import { periodMacroMetric, projectAllTimeTopTasks } from "./server-period-macro-metric.js";
 import {
   buildCanonicalOperationsProjection,
   buildCurrentCostProjection,
   buildManifestCostRunPage,
   buildManifestFirstCostProjection,
-  filterCostRunRows,
   isUnfilteredCostRequest,
   knownWorkIds,
   normalizeWorkPriority,
-  pageCostRunRows,
   readCurrentFxRate,
   readWorkPriority,
 } from "./server-projections.js";
+import { isAllowedDashboardAuthority } from "./server-request-authority.js";
+import { refreshSqliteSnapshotInWorker } from "./server-snapshot-refresh.js";
+import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
 import { queryValues, selectedCurrency } from "./server-summary-helpers.js";
-import { dashboardIdentity, dashboardWorkspaceKey, reconcileOpenWork } from "./server-workspace.js";
+import {
+  dashboardIdentity,
+  dashboardWorkspaceKey,
+  type ReconciliationResult,
+  reconcileOpenWork,
+} from "./server-workspace.js";
 import {
   rebuildSqliteReadModel,
   SqliteReadModelFileSystem,
@@ -80,6 +80,7 @@ import {
 
 export { manifestRun, mergeManifestRuns } from "./manifest-runs.js";
 export { projectionPeriodFilter } from "./server-period.js";
+export { projectAllTimeTopTasks } from "./server-period-macro-metric.js";
 export {
   dashboardWorkspaceKey,
   githubRepositoryFromRemote,
@@ -93,28 +94,14 @@ export {
   validateSqliteReadModelSchema,
 } from "./sqlite-read-model.js";
 
-type AllTimeTopTaskFact = {
-  task_id: string;
-  total_duration_ms: number | null;
-  total_tokens: number | null;
-  total_cost_usd: number | null;
-  total_cost_brl: number | null;
-  total_run_count: number;
-};
-
-export function projectAllTimeTopTasks(
-  tasks: readonly AllTimeTopTaskFact[],
-): NonNullable<NonNullable<OperationsProjection["summary"]["overview_metrics"]>["top_tasks"]> {
-  return tasks.map((task) => ({
-    task_id: task.task_id,
-    duration_ms: task.total_duration_ms,
-    total_tokens: task.total_tokens,
-    total_cost_usd: task.total_cost_usd,
-    cost_brl: task.total_cost_brl,
-    run_count: task.total_run_count,
-  }));
+export function reconciliationNeedsRefresh(result: ReconciliationResult): boolean {
+  return result.reconciled_ids.length > 0 || result.blocked.length > 0;
 }
 
+type OverviewMacroMetrics = NonNullable<
+  NonNullable<OperationsProjection["summary"]["overview_metrics"]>["macro_metrics"]
+>;
+
 const API_PREFIX = "/api/v2";
 const HOST = "127.0.0.1";
 const RUNTIME_KIND = "zaip-dashboard-sqlite-runtime";
@@ -171,6 +158,8 @@ interface DashboardAppOptions {
   reconcileOpenWork?: typeof reconcileOpenWork;
   refreshReadModel?: () => Promise<void>;
   snapshotState?: "current" | "updating";
+  /** Test seam: health and reconciliation only require the asserted V2 layout. */
+  layout?: WorkspaceLayout;
 }
 
 class V2WorkspaceRequiredError extends Error {
@@ -233,7 +222,6 @@ function headOrJson(
   if (context.req.method === "HEAD") return context.body(null, status);
   return context.json(payload, status);
 }
-
 /**
  * Keep the entity/macro details on the snapshot filesystem, while making the
  * first-fold counters and token/cost facts come from SQL.
@@ -309,15 +297,23 @@ function buildSqliteOperationsProjection(
   const allTime =
     fullAllTime ??
     (filter.from === null && filter.to === null ? filesystem.firstFoldViewportAllTime() : null);
+  const allTimeBoard =
+    filter.from === null && filter.to === null && options.includeBoardTasks === true
+      ? filesystem.firstFoldBoardAllTime()
+      : null;
   const page = <T extends "task" | "spec" | "prd">(kind: T) =>
-    cachedMonthlyQuick?.pages[kind] ?? filesystem.summaryPage(kind, filter, 0, 10_000).rows;
+    cachedMonthlyQuick?.pages[kind] ??
+    allTimeBoard?.pages[kind] ??
+    filesystem.canonicalWorkPage(kind, filter, 0, 10_000).rows;
   const includeEntities = allTime === null || options.includeBoardTasks === true;
   const tasks = includeEntities ? page("task") : [];
   const specs = includeEntities ? page("spec") : [];
   const prds = includeEntities ? page("prd") : [];
   const aggregate =
     allTime?.aggregate ?? cachedMonthlyQuick?.aggregate ?? filesystem.firstFoldAggregate(filter);
-  const taskCount = allTime?.aggregate.task_count ?? tasks.length;
+  const legacyDraftCount = allTime?.task_status_counts.draft ?? 0;
+  const taskCount =
+    allTime === null ? tasks.length : Math.max(0, allTime.aggregate.task_count - legacyDraftCount);
   const allTimeTopTasks =
     filter.from === null &&
     filter.to === null &&
@@ -336,7 +332,10 @@ function buildSqliteOperationsProjection(
       : projectAllTimeTopTasks(allTimeTopTasks);
   const macroMetrics =
     fullAllTime === null
-      ? undefined
+      ? ({
+          specs: periodMacroMetric(specs, "spec"),
+          prds: periodMacroMetric(prds, "prd"),
+        } satisfies OverviewMacroMetrics)
       : (Object.fromEntries(
           (["specs", "prds"] as const).map((kind) => {
             const metric = fullAllTime.macro_metrics[kind];
@@ -372,7 +371,9 @@ function buildSqliteOperationsProjection(
         ) as NonNullable<
           NonNullable<OperationsProjection["summary"]["overview_metrics"]>["macro_metrics"]
         >);
-  const statuses: Record<string, number> = allTime?.task_status_counts ?? {};
+  const statuses: Record<string, number> = Object.fromEntries(
+    Object.entries(allTime?.task_status_counts ?? {}).filter(([status]) => status !== "draft"),
+  );
   const risks: Record<string, number> = allTime?.task_risk_counts ?? {};
   if (allTime === null) {
     for (const task of tasks) {
@@ -417,7 +418,7 @@ function buildSqliteOperationsProjection(
     schema_version: 2 as const,
     id: String(row.id),
     revision: 1,
-    change_id: "",
+    change_id: typeof row.change_id === "string" ? row.change_id : "",
     title: String(row.title ?? row.id),
     short_name: String(row.title ?? row.id),
     objective: "",
@@ -437,7 +438,8 @@ function buildSqliteOperationsProjection(
     result: null,
     artifact_path: ".agents/records",
     progress: 0,
-    spec_id: null,
+    spec_id: typeof row.spec_id === "string" ? row.spec_id : null,
+    origin: typeof row.origin === "string" ? row.origin : null,
     execution_started: false,
     telemetry: {
       duration_ms: nullableMetric(row.total_duration),
@@ -551,9 +553,6 @@ function buildSqliteOperationsProjection(
         origin_tokens_match_total: true,
       },
       usage,
-      // The period tabs are part of the first-fold contract too.  Supplying an
-      // empty object for the all-time fast path made Daily, Monthly and Annual
-      // look empty even though the SQLite daily aggregate already existed.
       periods: { daily: options.includePeriods === true ? dailyPeriods : {} },
     },
     origins: { conversation: usage, task: usage, spec: usage, prd: usage },
@@ -642,88 +641,6 @@ async function firstFoldCostSource(
   } satisfies CostSummarySource;
 }
 
-function buildSqliteTaskTrace(
-  filesystem: SqliteReadModelFileSystem,
-  layout: WorkspaceLayout,
-  taskId: string,
-): TaskTrace {
-  const initial = filesystem.canonicalTraceFiles([taskId]);
-  const taskFile = initial.find(
-    (row) =>
-      row.path.includes("/.agents/records/tasks/") || row.path.includes(".agents/records/tasks/"),
-  );
-  if (taskFile === undefined) throw new Error(`Canonical Task ${taskId} was not found`);
-  const scalar = (key: string): string | null => {
-    const frontMatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(taskFile.content)?.[1] ?? "";
-    const value = new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m").exec(frontMatter)?.[1]?.trim();
-    if (value === undefined || value === "null") return null;
-    return value.replace(/^['"]|['"]$/g, "");
-  };
-  const relatedId = (key: string, prefix: string): string | null =>
-    scalar(key) ?? new RegExp(`\\b${prefix}[A-Z0-9-]+`).exec(taskFile.content)?.[0] ?? null;
-  const changeId = relatedId("change_id", "CHG-") ?? taskId;
-  const specId = relatedId("spec_id", "SPEC-");
-  const prdId = relatedId("prd_id", "PRD-");
-  const markers = [taskId, changeId, specId, prdId].filter(
-    (value): value is string => value !== null,
-  );
-  const documents = filesystem
-    .canonicalTraceFiles(markers)
-    .filter(
-      (row) => /\.(?:md|json|jsonl|txt|log)$/i.test(row.path) && row.content.length <= 250_000,
-    )
-    .map((row) => {
-      const classification = classifyTraceDocument(row.path);
-      const timestamps = timestampsFromContent(row.content);
-      return {
-        id: createHash("sha256").update(row.path).digest("hex").slice(0, 16),
-        path: row.path,
-        title:
-          row.content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? row.path.split("/").at(-1) ?? row.path,
-        ...classification,
-        content: row.content,
-        ...timestamps,
-      } satisfies TraceDocument;
-    });
-  const stages = buildTraceStageRecords(documents);
-  const coveredStages = new Set(documents.map((document) => document.stage));
-  const risk = scalar("risk");
-  const status = scalar("status");
-  return {
-    schema_version: 2,
-    layout_version: layout.version as 2 | 3,
-    readonly: true,
-    source: ".agents/records",
-    task_id: taskId,
-    task_title: scalar("title") ?? taskFile.content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? taskId,
-    task_risk: risk === "lite" || risk === "standard" || risk === "critical" ? risk : null,
-    task_created_at: scalar("created_at"),
-    task_progress:
-      status === "completed"
-        ? 100
-        : status === "verifying"
-          ? 80
-          : status === "executing"
-            ? 50
-            : status === "blocked" || status === "failed" || status === "cancelled"
-              ? 0
-              : 10,
-    spec_id: specId,
-    prd_id: prdId,
-    change_id: changeId,
-    usage: filesystem.taskTraceUsage(taskId),
-    documents,
-    stages,
-    coverage: {
-      stages_with_documents: coveredStages.size,
-      stages_with_timestamps: stages.filter((stage) => stage.status === "recorded").length,
-      total_stages: 6,
-      evidence_count: documents.filter((document) => document.kind === "evidence").length,
-      test_count: documents.filter((document) => document.kind === "test").length,
-    },
-  };
-}
-
 export function createDashboardApp(
   workspaceRoot = process.env.ZAIP_WORKSPACE ?? process.cwd(),
   sessionToken = defaultSessionToken(),
@@ -737,7 +654,8 @@ export function createDashboardApp(
   // its V2 layout repeatedly costs hundreds of milliseconds per navigation;
   // canonical filesystems remain deliberately uncached.
   const sqliteLayout = isSqliteSnapshot ? requireV2Layout(filesystem) : null;
-  const readLayout = () => sqliteLayout ?? requireV2Layout(filesystem);
+  const readLayout = async () =>
+    options.layout ?? sqliteLayout ?? (await requireV2Layout(filesystem));
   const snapshotReadOnly = options.snapshotReadOnly ?? isSqliteSnapshot;
   const snapshotState = options.snapshotState ?? "current";
   const canonicalFilesystem = options.canonicalFilesystem ?? new WorkspaceFileSystem(workspaceRoot);
@@ -745,13 +663,7 @@ export function createDashboardApp(
   const refreshReadModel =
     options.refreshReadModel ??
     (async () => {
-      if (!isSqliteSnapshot) return;
-      // Explicit user refreshes must replace the immutable generation with the
-      // current canonical records. Keep stale-seed fallback exclusively for
-      // startup warmth, never for this visible convergence request.
-      await filesystem.rebuildAndRefresh(() =>
-        rebuildSqliteReadModel(workspaceRoot, { forceCanonical: true }),
-      );
+      if (isSqliteSnapshot) await refreshSqliteSnapshotInWorker(workspaceRoot, filesystem);
     });
   const workspaceKey = dashboardWorkspaceKey(workspaceRoot);
   const syncAgentAdapters = options.syncAgentAdapters ?? (() => runAgentAdapterSync(workspaceRoot));
@@ -839,6 +751,9 @@ export function createDashboardApp(
   };
 
   app.use("*", async (context, next) => {
+    if (!isAllowedDashboardAuthority(context.req.url, context.req.header("host"))) {
+      return context.json({ error: "Host rejected" }, 403);
+    }
     context.header("Cache-Control", "no-store");
     context.header("X-Content-Type-Options", "nosniff");
     context.header("Referrer-Policy", "no-referrer");
@@ -1089,6 +1004,7 @@ export function createDashboardApp(
               { from, to },
               {
                 includeTopTasks: from === null && to === null,
+                includeExtended: from === null && to === null,
               },
             ),
           context.req.query("fresh") === "1",
@@ -1194,6 +1110,13 @@ export function createDashboardApp(
       const value = context.req.query(name);
       return value === undefined ? {} : { [name]: value };
     };
+    const workListKind = context.req.query("kind");
+    if (
+      view === "operations_work_list" &&
+      workListKind !== undefined &&
+      !["all", "task", "standalone-task", "prd", "spec"].includes(workListKind)
+    )
+      return headOrJson(context, { error: "Unsupported Operations work-list kind" }, 400);
     return headOrJson(
       context,
       filesystem.viewPage(view as keyof typeof sqliteViewMetadata, {
@@ -1209,6 +1132,9 @@ export function createDashboardApp(
         ...optional("origin"),
         ...optional("workType"),
         ...optional("priority"),
+        ...(workListKind === undefined
+          ? {}
+          : { kind: workListKind as "all" | "task" | "standalone-task" | "prd" | "spec" }),
         offset: Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0),
         limit,
       }),
@@ -1295,13 +1221,19 @@ export function createDashboardApp(
     try {
       await readLayout();
       // The served snapshot is immutable by design. Reconciliation must use
-      // canonical records, then atomically rebuild and reopen the snapshot
-      // before the response exposes fresh projections.
+      // canonical records. When those records changed, atomically rebuild and
+      // reopen the snapshot before the response exposes fresh projections.
       const reconciledIds = await reconcileOpen(canonicalFilesystem, workspaceRoot);
-      await rebuildProjection();
+      // A clean reconciliation is the normal startup path. It changed no
+      // canonical data, so rebuilding the immutable SQLite snapshot only adds
+      // seconds of redundant work before the dashboard can settle.
+      if (reconciliationNeedsRefresh(reconciledIds)) {
+        await rebuildProjection();
+      }
       return context.json({
         ...(await readSnapshot(context)),
         reconciliation: reconciledIds,
+        projection_refresh_completed: reconciliationNeedsRefresh(reconciledIds),
       });
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
@@ -1409,6 +1341,50 @@ export function createDashboardApp(
     }
   });
 
+  /** Compact factual attribution view used by both Cost Monitor and Operations.
+   * It is intentionally read-only and is available only from a coherent SQLite
+   * generation, never by reopening mutable JSONL streams on a request. */
+  app.on(["GET", "HEAD"], `${API_PREFIX}/developers`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(
+        context,
+        { error: "Developer attribution requires the SQLite read model" },
+        409,
+      );
+    const { from, to } = projectionPeriodFilter(context);
+    return headOrJson(
+      context,
+      filesystem.developerCostAggregate({
+        from,
+        to,
+        accountIds: queryValues(context, "account_id"),
+      }),
+      200,
+      true,
+    );
+  });
+
+  /** Operations keeps its developer facts separate from Cost Monitor columns. */
+  app.on(["GET", "HEAD"], `${API_PREFIX}/operations/developers`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(
+        context,
+        { error: "Developer attribution requires the SQLite read model" },
+        409,
+      );
+    const { from, to } = projectionPeriodFilter(context);
+    return headOrJson(
+      context,
+      filesystem.operationsDeveloperAggregate({
+        from,
+        to,
+        accountIds: queryValues(context, "account_id"),
+      }),
+      200,
+      true,
+    );
+  });
+
   app.on(["GET", "HEAD"], `${API_PREFIX}/pricing`, async (context) =>
     headOrJson(
       context,

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

@@ -0,0 +1,28 @@
+export function developerArtifactCountsCte() {
+  return `, artifacts AS (
+        SELECT a.developer_account_id,
+          COUNT(DISTINCT CASE WHEN artifact.artifact_kind='validation' THEN artifact.source_path END) AS test_count,
+          COUNT(DISTINCT CASE WHEN artifact.artifact_kind='evidence' THEN artifact.source_path END) AS evidence_count
+        FROM selected a
+        JOIN canonical_artifacts artifact ON artifact.run_id=a.run_id
+          AND artifact.task_id=a.task_id
+          AND (artifact.change_id IS NULL OR artifact.change_id=a.change_id)
+        WHERE artifact.occurred_day_sp IS NOT NULL
+          AND (? IS NULL OR artifact.occurred_day_sp >= ?)
+          AND (? IS NULL OR artifact.occurred_day_sp <= ?)
+        GROUP BY a.developer_account_id
+      )`;
+}
+
+export function artifactStructuralRowsSql() {
+  return `UNION ALL
+        SELECT occurred_day_sp,
+          0, 0, 0,
+          SUM(CASE WHEN artifact_kind='validation' THEN 1 ELSE 0 END),
+          SUM(CASE WHEN artifact_kind='evidence' THEN 1 ELSE 0 END)
+        FROM canonical_artifacts
+        WHERE occurred_day_sp IS NOT NULL
+          AND (? IS NULL OR occurred_day_sp >= ?)
+          AND (? IS NULL OR occurred_day_sp <= ?)
+        GROUP BY occurred_day_sp`;
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-agent-page.test.ts

@@ -0,0 +1,63 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { isDateOnlyCostPage, readDateOnlyCostDimensionPage } from "./sqlite-cost-agent-page.js";
+
+describe("date-only Cost page", () => {
+  it("accepts only period input and keeps all custom filters on the canonical path", () => {
+    expect(isDateOnlyCostPage({ from: "2026-08-01", to: "2026-08-31" })).toBe(true);
+    expect(isDateOnlyCostPage({ from: "2026-08-01", agent: "leo" })).toBe(false);
+    expect(isDateOnlyCostPage({ query: "leo" })).toBe(false);
+  });
+
+  it("keeps residuals, multi-dimension membership, and global totals aligned", () => {
+    const database = new DatabaseSync(":memory:");
+    try {
+      database.exec(
+        `CREATE TABLE zaip_aios_activities (payload_type TEXT, activity_source_kind TEXT, occurred_day_sp TEXT, agent_invocation_id TEXT, task_id TEXT, duration_ms REAL, source_event_count INTEGER, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL, model TEXT, provider TEXT, zaip_agent TEXT, zaip_agent_persona TEXT, zaip_agent_job TEXT, occurred_at TEXT); CREATE TABLE cost_invocation_dimension_facts (agent_invocation_id TEXT, occurred_day_sp TEXT, model TEXT, provider TEXT, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL); CREATE TABLE zaip_dim_zaip_agent (zaip_agent TEXT, persona TEXT, job TEXT);`,
+      );
+      const activity = database.prepare(
+        "INSERT INTO zaip_aios_activities(payload_type,activity_source_kind,occurred_day_sp,agent_invocation_id,task_id,duration_ms,source_event_count,total_tokens,cost_usd,cost_brl) VALUES (NULL,'agent_run','2026-08-01',?,?,?,?,?,?,?)",
+      );
+      activity.run("a", "task-a", 100, 1, 100, 6, 10);
+      activity.run("b", "task-b", 200, 2, 100, 10, 10);
+      const fact = database.prepare(
+        "INSERT INTO cost_invocation_dimension_facts VALUES (?,?,?,?,NULL,NULL,NULL,NULL,?,?,?)",
+      );
+      fact.run("a", "2026-08-01", "gpt", "openai", 60, 6, 60);
+      fact.run("b", "2026-08-01", "gpt", "openai", 50, 5, 50);
+      fact.run("b", "2026-08-01", "claude", "anthropic", 50, 5, 50);
+      for (const dimension of ["model", "provider"] as const) {
+        const page = readDateOnlyCostDimensionPage(
+          database,
+          dimension,
+          "2026-08-01",
+          "2026-08-31",
+          10,
+          0,
+        );
+        expect(page.totals).toMatchObject({
+          invocation_count: 2,
+          task_count: 2,
+          total_duration: 300,
+          source_event_count: 3,
+          total_tokens: 200,
+          total_cost_brl: 20,
+        });
+        const known = dimension === "model" ? "gpt" : "openai";
+        expect(page.rows.find((row) => row.key === known)).toMatchObject({
+          invocation_count: 1,
+          task_count: 2,
+          total_duration: 100,
+          total_tokens: 110,
+        });
+        expect(page.rows.find((row) => row.key === "unavailable")).toMatchObject({
+          invocation_count: 0,
+          task_count: 2,
+          total_tokens: 40,
+        });
+      }
+    } finally {
+      database.close();
+    }
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-agent-page.ts

@@ -0,0 +1,109 @@
+/**
+ * Date-only Cost pages can use immutable, indexed activity facts.  Any
+ * additional filter deliberately falls back to the canonical SQL path, whose
+ * relationship semantics need the richer views.
+ */
+export type DateOnlyCostPageInput = {
+  from?: string | null;
+  to?: string | null;
+  query?: string;
+  status?: string;
+  risk?: string;
+  provider?: string;
+  model?: string;
+  agent?: string;
+  phase?: string;
+  origin?: string;
+  workType?: string;
+  priority?: string;
+};
+
+export function isDateOnlyCostPage(input: DateOnlyCostPageInput): boolean {
+  return (
+    (input.from !== undefined || input.to !== undefined) &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority
+  );
+}
+
+/** SQL is built only from normalized Sao Paulo day keys. */
+export function costDimensionFactDateFilter(input: DateOnlyCostPageInput): string {
+  const day = (value: string | null | undefined) =>
+    value && /^\d{4}-\d{2}-\d{2}/.test(value) ? value.slice(0, 10) : null;
+  const clauses = [
+    day(input.from) && `occurred_day_sp >= '${day(input.from)}'`,
+    day(input.to) && `occurred_day_sp <= '${day(input.to)}'`,
+  ].filter((value): value is string => Boolean(value));
+  return clauses.length === 0 ? "" : ` AND ${clauses.join(" AND ")}`;
+}
+
+type CostDimension = "agent" | "model" | "provider";
+type SqliteQuery = {
+  prepare(sql: string): {
+    get(...values: Array<string | number>): Record<string, unknown> | undefined;
+    all(...values: Array<string | number>): Array<Record<string, unknown>>;
+  };
+};
+
+/** Reads the date picker population from schema-67 physical facts only. */
+export function readDateOnlyCostDimensionPage(
+  database: SqliteQuery,
+  dimension: CostDimension,
+  from: string,
+  to: string,
+  limit: number,
+  offset: number,
+) {
+  if (dimension === "agent") {
+    const facts = `WITH facts AS (SELECT zaip_agent AS key, zaip_agent_persona AS persona, zaip_agent_job AS job, occurred_at, task_id, duration_ms, source_event_count, total_tokens, cost_usd, cost_brl FROM zaip_aios_activities WHERE payload_type IS NULL AND occurred_day_sp>=? AND occurred_day_sp<=? AND zaip_agent IS NOT NULL AND (activity_source_kind='agent_run' OR (activity_source_kind<>'agent_run' AND (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL))))`;
+    const total_count = Number(
+      database.prepare(`${facts} SELECT COUNT(DISTINCT key) AS count FROM facts`).get(from, to)
+        ?.count ?? 0,
+    );
+    const totals =
+      database
+        .prepare(
+          `${facts} SELECT COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM facts`,
+        )
+        .get(from, to) ?? {};
+    const rows = database
+      .prepare(
+        `${facts} SELECT key, key AS label, COALESCE(MAX(persona), (SELECT persona FROM zaip_dim_zaip_agent d WHERE d.zaip_agent=key)) AS persona, COALESCE(MAX(job), (SELECT job FROM zaip_dim_zaip_agent d WHERE d.zaip_agent=key)) AS job, MAX(occurred_at) AS latest_started_at, COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM facts GROUP BY key ORDER BY total_cost_brl DESC, key LIMIT ? OFFSET ?`,
+      )
+      .all(from, to, limit, offset);
+    return { total_count, totals, rows };
+  }
+  const field = dimension === "model" ? "model" : "provider";
+  const directFinancial =
+    dimension === "model"
+      ? ` UNION ALL SELECT CASE WHEN a.${field} IS NULL OR trim(a.${field})='' OR lower(a.${field}) IN ('unavailable','unknown','mixed') THEN 'unavailable' ELSE a.${field} END,a.total_tokens,a.cost_usd,a.cost_brl FROM zaip_aios_activities a WHERE a.payload_type IS NULL AND a.activity_source_kind<>'agent_run' AND a.occurred_day_sp>=? AND a.occurred_day_sp<=? AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)`
+      : "";
+  const cte = `WITH base AS (SELECT agent_invocation_id, task_id, duration_ms, source_event_count, input_tokens, cached_input_tokens, output_tokens, reasoning_tokens, total_tokens, cost_usd, cost_brl FROM zaip_aios_activities WHERE payload_type IS NULL AND activity_source_kind='agent_run' AND occurred_day_sp>=? AND occurred_day_sp<=?), segment_totals AS (SELECT f.agent_invocation_id,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) cost_usd,SUM(f.cost_brl) cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id), segments AS (SELECT f.agent_invocation_id,CASE WHEN f.${field} IS NULL OR trim(f.${field})='' OR lower(f.${field}) IN ('unavailable','unknown','mixed') THEN 'unavailable' ELSE f.${field} END key,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) total_cost_usd,SUM(f.cost_brl) total_cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id,key UNION ALL SELECT b.agent_invocation_id,'unavailable',b.input_tokens-COALESCE(t.input_tokens,0),b.cached_input_tokens-COALESCE(t.cached_input_tokens,0),b.output_tokens-COALESCE(t.output_tokens,0),b.reasoning_tokens-COALESCE(t.reasoning_tokens,0),b.total_tokens-COALESCE(t.total_tokens,0),b.cost_usd-COALESCE(t.cost_usd,0),b.cost_brl-COALESCE(t.cost_brl,0) FROM base b LEFT JOIN segment_totals t USING(agent_invocation_id) WHERE (b.total_tokens IS NOT NULL OR b.cost_usd IS NOT NULL OR b.cost_brl IS NOT NULL) AND (b.total_tokens<>COALESCE(t.total_tokens,0) OR b.cost_usd<>COALESCE(t.cost_usd,0) OR b.cost_brl<>COALESCE(t.cost_brl,0))), dimension_segments AS (SELECT agent_invocation_id,key,SUM(input_tokens) input_tokens,SUM(cached_input_tokens) cached_input_tokens,SUM(output_tokens) output_tokens,SUM(reasoning_tokens) reasoning_tokens,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM segments GROUP BY agent_invocation_id,key), known_dimensions AS (SELECT agent_invocation_id,COUNT(DISTINCT key) dimension_count FROM dimension_segments WHERE key<>'unavailable' GROUP BY agent_invocation_id), filtered_segments AS (SELECT s.*,b.task_id,b.duration_ms,b.source_event_count,d.dimension_count FROM segments s JOIN base b USING(agent_invocation_id) LEFT JOIN known_dimensions d USING(agent_invocation_id)), financial_components AS (SELECT key,total_tokens,total_cost_usd,total_cost_brl FROM filtered_segments${directFinancial}), financial AS (SELECT key,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM financial_components GROUP BY key), population_dimensions AS (SELECT agent_invocation_id,key,MAX(task_id) task_id,MAX(duration_ms) duration_ms,MAX(source_event_count) source_event_count,MAX(dimension_count) dimension_count FROM filtered_segments GROUP BY agent_invocation_id,key), population_ranked AS (SELECT *,ROW_NUMBER() OVER (PARTITION BY agent_invocation_id ORDER BY key) dimension_rank FROM population_dimensions), population AS (SELECT key,COUNT(*) invocation_count,SUM(duration_ms) total_duration,SUM(source_event_count) source_event_count FROM population_ranked WHERE dimension_rank=1 AND dimension_count=1 GROUP BY key), task_population AS (SELECT key,COUNT(*) task_count FROM (SELECT task_id,key FROM population_dimensions WHERE task_id IS NOT NULL GROUP BY task_id,key) GROUP BY key), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population)`;
+  const args =
+    dimension === "model"
+      ? [from, to, from, to, from, to, from, to]
+      : [from, to, from, to, from, to];
+  const total_count = Number(
+    database.prepare(`${cte} SELECT COUNT(*) AS count FROM keys`).get(...args)?.count ?? 0,
+  );
+  const totals =
+    database
+      .prepare(
+        `${cte} SELECT (SELECT COUNT(*) FROM population_ranked WHERE dimension_rank=1) invocation_count, (SELECT COUNT(DISTINCT task_id) FROM population_dimensions) task_count, (SELECT SUM(duration_ms) FROM population_ranked WHERE dimension_rank=1) total_duration, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) FROM population_ranked WHERE dimension_rank=1) duration_unknown, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) FROM population_ranked WHERE dimension_rank=1) duration_known, (SELECT SUM(source_event_count) FROM population_ranked WHERE dimension_rank=1) source_event_count, (SELECT SUM(input_tokens) FROM filtered_segments) total_input_tokens, (SELECT SUM(cached_input_tokens) FROM filtered_segments) total_cached_input_tokens, (SELECT SUM(output_tokens) FROM filtered_segments) total_output_tokens, (SELECT SUM(reasoning_tokens) FROM filtered_segments) total_reasoning_tokens, (SELECT SUM(total_tokens) FROM filtered_segments) total_tokens, (SELECT SUM(total_cost_usd) FROM filtered_segments) total_cost_usd, (SELECT SUM(total_cost_brl) FROM filtered_segments) total_cost_brl`,
+      )
+      .get(...args) ?? {};
+  const rows = database
+    .prepare(
+      `${cte} SELECT keys.key,keys.key AS label,COALESCE(population.invocation_count,0) invocation_count,COALESCE(task_population.task_count,0) 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 ?`,
+    )
+    .all(...args, limit, offset);
+  return { total_count, totals, rows };
+}