@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -1,13 +1,16 @@
 import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
 import { fxRateSchema, PricingRepository, pricingCatalogSchema } from "@zaip-ai/costs";
 import { type Context, Hono } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { captureActiveCodexTelemetry } from "./active-codex-telemetry.js";
+import {
+  type ActiveCodexTelemetryCapture,
+  captureActiveCodexTelemetry,
+} from "./active-codex-telemetry.js";
 import { runAgentAdapterSync } from "./agent-adapter-sync.js";
 import {
   type AgentAdapterSyncResult,
@@ -30,6 +33,7 @@ import {
   requireV2Layout,
   V2WorkspaceRequiredError,
 } from "./server-http-contracts.js";
+import { lifecycleManifestState } from "./server-lifecycle-diagnostics.js";
 import { registerOperationsRoutes } from "./server-operations-routes.js";
 import { projectionPeriodFilter } from "./server-period.js";
 import { buildFirstFoldQuickProjection, dashboardSnapshot } from "./server-read-projections.js";
@@ -131,9 +135,8 @@ function shouldBootstrapBrowserSession(context: Context): boolean {
  */
 
 /**
- * SQLite's files snapshot intentionally excludes derived lifecycle manifests.
- * Build the Operations first fold from its canonical SQL views instead of
- * treating a missing manifest as a broken workspace.
+ * SQLite snapshots intentionally exclude derived lifecycle manifests. Manifest
+ * health is therefore always read from the canonical filesystem.
  */
 
 export function createDashboardApp(
@@ -162,6 +165,8 @@ export function createDashboardApp(
       if (isSqliteSnapshot) await refreshSqliteSnapshotInWorker(workspaceRoot, filesystem);
     });
   const workspaceKey = dashboardWorkspaceKey(workspaceRoot);
+  const workspace = resolve(workspaceRoot);
+  const workspaceName = basename(workspace);
   const syncAgentAdapters = options.syncAgentAdapters ?? (() => runAgentAdapterSync(workspaceRoot));
   let catalogWriteTail = Promise.resolve();
   type DashboardSnapshot = Awaited<ReturnType<typeof dashboardSnapshot>>;
@@ -213,6 +218,7 @@ export function createDashboardApp(
   let observedSnapshotRevision: string | null = null;
   const projectionRefreshDiagnostics = createProjectionRefreshDiagnostics();
   let activeCaptureFailure: { code: string; occurred_at: string; cause: string } | null = null;
+  let activeCapture: ActiveCodexTelemetryCapture | null = null;
   let projectionRefreshInFlight: Promise<void> | null = null;
   let projectionRefreshRequested = false;
   const rebuildProjection = async () => {
@@ -263,7 +269,8 @@ export function createDashboardApp(
       ? { captureActiveTelemetry: () => captureActiveCodexTelemetry(workspaceRoot) }
       : {}),
     onRefreshFailure: projectionRefreshDiagnostics.record,
-    onCaptureSuccess: () => {
+    onCaptureSuccess: (result) => {
+      activeCapture = result;
       activeCaptureFailure = null;
     },
     onCaptureFailure: (error) => {
@@ -403,20 +410,30 @@ export function createDashboardApp(
   registerBrowserLeaseRoute(app, API_PREFIX, options.launcherOwned === true);
   app.on(["GET", "HEAD"], `${API_PREFIX}/health`, async (context) => {
     try {
-      const layout = await readLayout();
+      const [layout, manifestState] = await Promise.all([
+        readLayout(),
+        lifecycleManifestState(canonicalFilesystem),
+      ]);
       return headOrJson(context, {
         kind: RUNTIME_KIND,
         workspaceKey,
+        workspace,
+        workspace_name: workspaceName,
+        server_pid: process.pid,
         service: "zaip-aios-dashboard",
         status:
-          activeCaptureFailure === null ? projectionRefreshDiagnostics.healthStatus : "degraded",
+          manifestState === "initialized" && activeCaptureFailure === null
+            ? projectionRefreshDiagnostics.healthStatus
+            : "degraded",
         api_version: 2,
         workspace_layout: layout.version,
+        lifecycle_manifest_state: manifestState,
         read_only: true,
         storage: isSqliteSnapshot ? filesystem.metadata() : { storage_mode: "filesystem" },
         snapshot_state: snapshotState,
         projection_refresh_failure: projectionRefreshDiagnostics.failure,
         active_capture_failure: activeCaptureFailure,
+        active_capture: activeCapture,
       });
     } catch (error) {
       return headOrJson(
@@ -424,6 +441,9 @@ export function createDashboardApp(
         {
           kind: RUNTIME_KIND,
           workspaceKey,
+          workspace,
+          workspace_name: workspaceName,
+          server_pid: process.pid,
           service: "zaip-aios-dashboard",
           status: "unavailable",
           api_version: 2,
@@ -438,7 +458,12 @@ export function createDashboardApp(
   // intentionally remains a lightweight process/layout probe.
   app.on(["GET", "HEAD"], `${API_PREFIX}/ready`, async (context) => {
     try {
-      const layout = await readLayout();
+      const [layout, manifestState] = await Promise.all([
+        readLayout(),
+        lifecycleManifestState(canonicalFilesystem),
+      ]);
+      const readinessStatus =
+        manifestState === "initialized" && activeCaptureFailure === null ? "ready" : "degraded";
       if (isSqliteSnapshot) {
         const revision = readCommittedSnapshotRevision(workspaceRoot);
         if (observedSnapshotRevision !== null && observedSnapshotRevision !== revision) {
@@ -453,8 +478,12 @@ export function createDashboardApp(
         return headOrJson(context, {
           kind: RUNTIME_KIND,
           workspaceKey,
-          status: "ready",
+          workspace,
+          workspace_name: workspaceName,
+          server_pid: process.pid,
+          status: readinessStatus,
           workspace_layout: layout.version,
+          lifecycle_manifest_state: manifestState,
           storage_mode: metadata.storage_mode,
           activity_count: metadata.activity_count,
           // Readiness is only an immutable-generation probe. The default
@@ -464,6 +493,7 @@ export function createDashboardApp(
           snapshot_state: snapshotState,
           projection_refresh_failure: projectionRefreshDiagnostics.failure,
           active_capture_failure: activeCaptureFailure,
+          active_capture: activeCapture,
           snapshot_revision: revision,
         });
       }
@@ -474,8 +504,13 @@ export function createDashboardApp(
       return headOrJson(context, {
         kind: RUNTIME_KIND,
         workspaceKey,
-        status: "ready",
+        workspace,
+        workspace_name: workspaceName,
+        server_pid: process.pid,
+        status: readinessStatus,
+        lifecycle_manifest_state: manifestState,
         source_latest_at: projection.summary.source_latest_at,
+        active_capture: activeCapture,
       });
     } catch (error) {
       return headOrJson(

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-filter-matrix.test.ts

@@ -0,0 +1,188 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { expect, it } from "vitest";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+it.each([
+  "draft",
+  "planned",
+  "executing",
+  "verifying",
+  "completed",
+  "blocked",
+  "cancelled",
+  "failed",
+])("preserves measured time, tokens and cost across all cost groupings for canonical Task status %s", async (status) => {
+  const parent = resolve(import.meta.dirname, "../../../../../../.tmp/sqlite-read-model-tests");
+  await mkdir(parent, { recursive: true });
+  const root = await mkdtemp(join(parent, "cost-filter-matrix-"));
+  let fs: SqliteReadModelFileSystem | undefined;
+  try {
+    const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    await mkdir(join(root, ".agents/records/tasks/2026/08"), { recursive: true });
+    for (const [id, priority] of [
+      ["TASK-MULTI", "high"],
+      ["TASK-LOW", "low"],
+    ]) {
+      await writeFile(
+        join(root, `.agents/records/tasks/2026/08/${id}.md`),
+        `---\nid: ${id}\ntitle: ${id}\nstatus: ${priority === "low" ? status : "completed"}\npriority: ${priority}\nrisk: standard\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n`,
+      );
+    }
+    const events = [
+      {
+        ...started,
+        task_id: "TASK-LOW",
+        work_type: "rework",
+        agent_invocation_id: "AINV-LOW",
+        root_agent_invocation_id: "AINV-LOW",
+        execution_id: "EXEC-LOW",
+        conversation_id: "CONV-LOW",
+      },
+      usage(2, "openai", "gpt-a", 7, 3.5),
+      { ...finished, sequence: 3 },
+    ].map((event, index) => ({
+      ...event,
+      run_id: "RUN-LOW",
+      event_id: `RUN-LOW:${index + 1}`,
+      occurred_at: index === 0 ? "2026-08-04T18:00:00.000Z" : "2026-08-04T18:01:00.000Z",
+      ...(event.type === "usage.recorded"
+        ? {
+            source_started_at: "2026-08-04T18:00:00.000Z",
+            source_finished_at: "2026-08-04T18:01:00.000Z",
+          }
+        : {}),
+    }));
+    await writeFile(
+      join(root, ".agents/records/runs/2026/08/RUN-LOW.jsonl"),
+      events.map((event) => JSON.stringify(event)).join("\n") + "\n",
+    );
+    await rebuildSqliteReadModel(root);
+    fs = new SqliteReadModelFileSystem(root);
+    const summary = fs.costMonitorSummaryAggregate({ from: null, to: null });
+    // Summary first paint remains aggregate-only, but its controls retain
+    // factual filter choices from the same SQLite population.
+    expect(summary.run_metrics).toBeUndefined();
+    expect(summary.filters_available).toMatchObject({
+      providers: expect.arrayContaining(["anthropic", "openai"]),
+      agents: expect.arrayContaining(["agent"]),
+      models: expect.arrayContaining(["claude-b", "gpt-a"]),
+      statuses: expect.arrayContaining(["completed"]),
+      priorities: expect.arrayContaining(["high", "low"]),
+      risks: expect.arrayContaining(["standard"]),
+      phases: expect.arrayContaining(["execution"]),
+      origins: expect.arrayContaining(["task"]),
+      work_types: expect.arrayContaining(["new", "rework"]),
+    });
+    const selectedSummary = fs.costMonitorSummaryAggregate({
+      from: null,
+      to: null,
+      priorities: ["low"],
+      risks: ["standard"],
+      origins: ["task"],
+      workTypes: ["rework"],
+    });
+    expect(selectedSummary.run_metrics).toBeUndefined();
+    expect(selectedSummary.filters_available).toMatchObject({
+      priorities: ["low"],
+      risks: ["standard"],
+      origins: ["task"],
+      work_types: ["rework"],
+      providers: ["openai"],
+      models: ["gpt-a"],
+    });
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+      "cost_monitor_tasks",
+      "cost_monitor_executions",
+      "cost_monitor_conversations",
+      "cost_monitor_zaip_agents",
+      "cost_monitor_models",
+      "cost_monitor_providers",
+      "cost_monitor_agent_invocations",
+    ] as const) {
+      for (const filter of [
+        { priority: "low" },
+        { workType: "rework" },
+        { priority: "low", workType: "rework" },
+        { priority: "low", status },
+        { priority: "low", risk: "standard", origin: "task", status, workType: "rework" },
+      ]) {
+        const page = fs.viewPage(view, filter);
+        expect(page.total_count, `${view} ${JSON.stringify(filter)}`).toBeGreaterThan(0);
+        const tokens = page.rows.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0);
+        expect(tokens, `${view} ${JSON.stringify(filter)} tokens`).toBe(7);
+        for (const [metric, expected] of Object.entries({
+          total_duration: 60_000,
+          total_cost_usd: 0.7,
+          total_cost_brl: 3.5,
+        })) {
+          const key =
+            view === "cost_monitor_agent_invocations"
+              ? ({
+                  total_duration: "duration_ms",
+                  total_cost_usd: "cost_usd",
+                  total_cost_brl: "cost_brl",
+                }[metric] ?? metric)
+              : metric;
+          const total = page.rows.reduce((sum, row) => sum + Number(row[key] ?? 0), 0);
+          expect(total, `${view} ${JSON.stringify(filter)} ${metric}`).toBeCloseTo(expected, 6);
+        }
+        expect(fs.viewPage(view, { ...filter, offset: 200 }).rows).toEqual([]);
+      }
+      expect(fs.viewPage(view, { priority: "high", workType: "rework" }).total_count, view).toBe(0);
+    }
+    if (status === "blocked") {
+      fs.close();
+      fs = undefined;
+      const unknown = [
+        {
+          ...started,
+          task_id: "TASK-LOW",
+          agent_invocation_id: "AINV-GAP",
+          root_agent_invocation_id: "AINV-GAP",
+        },
+        {
+          ...usage(2, "openai", "unknown-model", 5, 0),
+          source_started_at: undefined,
+          source_finished_at: undefined,
+          cost: { usd: null, brl: null, fx_rate: null },
+        },
+        { ...finished, sequence: 3, duration_ms: null, duration_provenance: "unavailable" },
+      ].map((event, index) => ({
+        ...event,
+        run_id: "RUN-GAP",
+        event_id: `RUN-GAP:${index + 1}`,
+        occurred_at: "2026-08-04T18:02:00.000Z",
+      }));
+      await writeFile(
+        join(root, ".agents/records/runs/2026/08/RUN-GAP.jsonl"),
+        unknown.map((event) => JSON.stringify(event)).join("\n") + "\n",
+      );
+      await rebuildSqliteReadModel(root);
+      fs = new SqliteReadModelFileSystem(root);
+      for (const view of [
+        "cost_monitor_daily",
+        "cost_monitor_monthly",
+        "cost_monitor_annual",
+      ] as const) {
+        const page = fs.viewPage(view, { priority: "low" });
+        expect(page.rows).toHaveLength(1);
+        expect(page.rows[0], view).toMatchObject({
+          total_tokens: 12,
+          total_duration: 60_000,
+          duration_known: 60_000,
+          duration_unknown: 1,
+          total_cost_brl: 3.5,
+        });
+        expect(page.totals, view).toMatchObject({ total_duration: 60_000, duration_unknown: 1 });
+      }
+    }
+  } finally {
+    fs?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-summary-details.test.ts

@@ -0,0 +1,85 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { buildCostSummaryDetails } from "./sqlite-cost-summary-details.js";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+
+it("decodes historical filter dimensions once while preserving canonical status and financial totals", () => {
+  const database = new DatabaseSync(":memory:");
+  const reads = { usage: 0, task: 0 };
+  const population = 1000;
+  try {
+    database.function("observe_usage", (id) => {
+      reads.usage += 1;
+      return id;
+    });
+    database.function("observe_task", (id) => {
+      reads.task += 1;
+      return id;
+    });
+    database.exec(`
+      CREATE TABLE runs (agent_run_id TEXT, task_id TEXT, model TEXT, provider TEXT,
+        total_tokens REAL, cost_usd REAL, cost_brl REAL, zaip_agent TEXT,
+        status TEXT, phase TEXT, prd_id TEXT, spec_id TEXT, work_key TEXT);
+      CREATE TABLE usage_source (id TEXT, provider TEXT, model TEXT);
+      CREATE TABLE task_source (id TEXT, status TEXT, priority TEXT, risk TEXT);
+      CREATE VIEW invocation_usage AS SELECT observe_usage(id) AS agent_invocation_id,
+        provider, model FROM usage_source;
+      CREATE VIEW canonical_work_items AS SELECT 'task' AS entity_kind,
+        observe_task(id) AS id, status, priority, risk FROM task_source;
+      CREATE TABLE cost_invocation_dimension_facts (agent_invocation_id TEXT,
+        model TEXT, total_tokens REAL, cost_usd REAL, cost_brl REAL);
+      CREATE INDEX cost_facts_invocation ON cost_invocation_dimension_facts(agent_invocation_id);
+    `);
+    const run = database.prepare(
+      "INSERT INTO runs VALUES (?,?,'model-a','provider-a',100,1,5,'rafa','executing','execution',NULL,NULL,'new')",
+    );
+    const usage = database.prepare("INSERT INTO usage_source VALUES (?,'provider-a','model-a')");
+    const task = database.prepare(
+      "INSERT INTO task_source VALUES (?,'completed','high','standard')",
+    );
+    const fact = database.prepare(
+      "INSERT INTO cost_invocation_dimension_facts VALUES (?,'model-a',80,0.8,4)",
+    );
+    for (let index = 0; index < population; index += 1) {
+      run.run(`run-${index}`, `task-${index}`);
+      usage.run(`run-${index}`);
+      task.run(`task-${index}`);
+      fact.run(`run-${index}`);
+    }
+    database.exec(
+      "INSERT INTO runs VALUES (NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,'blocked','conversation',NULL,NULL,'rework')",
+    );
+    const details = buildCostSummaryDetails(
+      { database } as SqliteQueryContext,
+      "WITH selected AS MATERIALIZED (SELECT * FROM runs)",
+      [],
+      (value) => (typeof value === "number" ? value : 0),
+      (value) => (typeof value === "number" ? value : null),
+    );
+    expect(details.filters_available).toEqual({
+      providers: ["provider-a", "unavailable"],
+      models: ["model-a", "unavailable"],
+      agents: ["rafa"],
+      statuses: ["blocked", "completed"],
+      priorities: ["high", "none"],
+      risks: ["none", "standard"],
+      phases: ["conversation", "execution"],
+      origins: ["conversation", "task"],
+      work_types: ["new", "rework"],
+    });
+    expect(details.model_groups.find((group) => group.key === "model-a")).toMatchObject({
+      total_tokens: population * 80,
+      estimated_brl: population * 4,
+    });
+    expect(details.model_groups.find((group) => group.key === "unavailable")).toMatchObject({
+      total_tokens: population * 20,
+      estimated_brl: population,
+    });
+    // Count decoded rows, not elapsed time: an inlined view causes quadratic
+    // nested scans even on a fast machine and must fail this regression.
+    expect(reads.usage).toBe(population);
+    expect(reads.task).toBe(population);
+  } finally {
+    database.close();
+  }
+});

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

@@ -0,0 +1,147 @@
+import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+
+type NumberValue = (value: unknown) => number;
+type NullableValue = (value: unknown) => number | null;
+type CostSummaryDetails = {
+  model_groups: NonNullable<CostSummarySource["model_groups"]>;
+  filters_available: NonNullable<CostSummarySource["filters_available"]>;
+};
+
+export function buildCostSummaryDetails(
+  context: SqliteQueryContext,
+  selected: string,
+  values: readonly (string | number | null)[],
+  number: NumberValue,
+  nullable: NullableValue,
+): CostSummaryDetails {
+  const summaryModelRows = context.database
+    .prepare(`${selected},
+      segment_totals AS (
+        SELECT agent_invocation_id, SUM(total_tokens) AS total_tokens,
+          SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM cost_invocation_dimension_facts
+        WHERE total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL
+        GROUP BY agent_invocation_id
+      ), components AS (
+        -- Agent facts can contain several observed models. Attribute their
+        -- financial components to the model segment, never to a mixed parent.
+        SELECT CASE WHEN f.model IS NULL OR trim(f.model) = '' OR lower(f.model) IN ('unavailable', 'unknown', 'mixed')
+               THEN 'unavailable' ELSE f.model END AS key,
+          SUM(f.total_tokens) AS total_tokens, SUM(f.cost_usd) AS total_cost_usd,
+          SUM(f.cost_brl) AS total_cost_brl
+        FROM selected s JOIN cost_invocation_dimension_facts f
+          ON f.agent_invocation_id=s.agent_run_id
+        WHERE s.agent_run_id IS NOT NULL
+        GROUP BY key
+        UNION ALL
+        -- Non-agent financial facts have no invocation segments, so their
+        -- observed model remains the only factual dimension.
+        SELECT CASE WHEN model IS NULL OR trim(model) = '' OR lower(model) IN ('unavailable', 'unknown', 'mixed')
+               THEN 'unavailable' ELSE model END AS key,
+          SUM(total_tokens), SUM(cost_usd), SUM(cost_brl)
+        FROM selected WHERE agent_run_id IS NULL GROUP BY key
+        UNION ALL
+        -- Preserve any consolidated invocation remainder as Sem dimensão so
+        -- the model chart reconciles to the same financial population.
+        SELECT 'unavailable' AS key,
+          SUM(s.total_tokens - COALESCE(st.total_tokens, 0)),
+          SUM(s.cost_usd - COALESCE(st.cost_usd, 0)),
+          SUM(s.cost_brl - COALESCE(st.cost_brl, 0))
+        FROM selected s LEFT JOIN segment_totals st ON st.agent_invocation_id=s.agent_run_id
+        WHERE s.agent_run_id IS NOT NULL
+          AND (s.total_tokens <> COALESCE(st.total_tokens, 0)
+            OR s.cost_usd <> COALESCE(st.cost_usd, 0)
+            OR s.cost_brl <> COALESCE(st.cost_brl, 0))
+      )
+      SELECT key, 0 AS invocation_count, NULL AS task_count,
+        NULL AS total_duration, 0 AS duration_unknown, 0 AS duration_known,
+        0 AS source_event_count, SUM(total_tokens) AS total_tokens,
+        SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl
+      FROM components GROUP BY key ORDER BY total_cost_brl DESC, key`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const model_groups = summaryModelRows.map((row) => {
+    const duration = nullable(row.total_duration);
+    const durationUnknown = number(row.duration_unknown);
+    const durationKnown = nullable(row.duration_known) ?? duration ?? 0;
+    return {
+      key: String(row.key ?? "unavailable"),
+      label: String(row.label ?? row.key ?? "unavailable"),
+      latest_started_at: "",
+      run_count: number(row.invocation_count),
+      task_count: nullable(row.task_count),
+      prd_count: 0,
+      spec_count: 0,
+      evidence_count: 0,
+      test_count: 0,
+      event_count: number(row.source_event_count),
+      total_tokens: nullable(row.total_tokens),
+      estimated_usd: nullable(row.total_cost_usd),
+      estimated_brl: nullable(row.total_cost_brl),
+      duration_ms: duration,
+      duration: {
+        known_sum: durationKnown,
+        unknown: durationUnknown,
+        complete: durationUnknown === 0,
+        coverage_ratio: durationUnknown === 0 ? 1 : 0,
+      },
+      coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+    };
+  });
+  const availabilityRows = context.database
+    .prepare(`${selected},
+      usage AS MATERIALIZED (
+        SELECT agent_invocation_id, provider, model FROM invocation_usage
+      ), canonical_tasks AS MATERIALIZED (
+        SELECT id, status, priority, risk FROM canonical_work_items WHERE entity_kind='task'
+      ), dimensions AS (
+        SELECT 'providers' AS dimension, COALESCE(NULLIF(trim(u.provider), ''), 'unavailable') AS value
+        FROM selected s JOIN usage u ON u.agent_invocation_id=s.agent_run_id
+        UNION ALL
+        SELECT 'models', COALESCE(NULLIF(trim(u.model), ''), 'unavailable')
+        FROM selected s JOIN usage u ON u.agent_invocation_id=s.agent_run_id
+        UNION ALL
+        SELECT 'providers', COALESCE(NULLIF(trim(s.provider), ''), 'unavailable')
+        FROM selected s WHERE s.agent_run_id IS NULL
+        UNION ALL
+        SELECT 'models', COALESCE(NULLIF(trim(s.model), ''), 'unavailable')
+        FROM selected s WHERE s.agent_run_id IS NULL
+        UNION ALL
+        SELECT 'agents', NULLIF(trim(s.zaip_agent), '') FROM selected s
+        UNION ALL
+        SELECT 'statuses', COALESCE(NULLIF(trim(task.status), ''), NULLIF(trim(s.status), ''), 'none')
+        FROM selected s LEFT JOIN canonical_tasks task ON task.id=s.task_id
+        UNION ALL
+        SELECT 'priorities', COALESCE(NULLIF(trim(task.priority), ''), 'none')
+        FROM selected s LEFT JOIN canonical_tasks task ON task.id=s.task_id
+        UNION ALL
+        SELECT 'risks', COALESCE(NULLIF(trim(task.risk), ''), 'none')
+        FROM selected s LEFT JOIN canonical_tasks task ON task.id=s.task_id
+        UNION ALL
+        SELECT 'phases', NULLIF(trim(s.phase), '') FROM selected s
+        UNION ALL
+        SELECT 'origins', CASE WHEN s.prd_id IS NOT NULL THEN 'prd'
+          WHEN s.spec_id IS NOT NULL THEN 'spec' WHEN s.task_id IS NOT NULL THEN 'task'
+          ELSE 'conversation' END FROM selected s
+        UNION ALL
+        SELECT 'work_types', NULLIF(trim(s.work_key), '') FROM selected s
+      ) SELECT dimension, value FROM dimensions WHERE value IS NOT NULL GROUP BY dimension, value
+      ORDER BY dimension, value`)
+    .all(...values) as Array<{ dimension: string; value: string }>;
+  const filters_available: Required<NonNullable<CostSummarySource["filters_available"]>> = {
+    providers: [],
+    agents: [],
+    models: [],
+    statuses: [],
+    priorities: [],
+    risks: [],
+    phases: [],
+    origins: [],
+    work_types: [],
+  };
+  for (const row of availabilityRows) {
+    const dimension = row.dimension as keyof typeof filters_available;
+    if (dimension in filters_available) filters_available[dimension].push(row.value);
+  }
+  return { model_groups, filters_available };
+}

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

@@ -0,0 +1,94 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import {
+  hasReconciledMacroDistributions,
+  readFirstFoldAllTime,
+} from "./sqlite-first-fold-cache.js";
+import type { SqliteFirstFoldAllTime } from "./sqlite-read-model-first-fold-types.js";
+
+function cachedFirstFold(
+  specs: { entityCount: number; statusCount: number; classificationCount: number },
+  prds: { entityCount: number; statusCount: number; classificationCount: number },
+) {
+  const macro = (item: {
+    entityCount: number;
+    statusCount: number;
+    classificationCount: number;
+  }) => ({
+    entity_count: item.entityCount,
+    status_counts: { executing: item.statusCount },
+    classification_counts: { structured: item.classificationCount },
+  });
+  return {
+    macro_metrics: { specs: macro(specs), prds: macro(prds) },
+  } as unknown as SqliteFirstFoldAllTime;
+}
+
+describe("first-fold all-time cache", () => {
+  it("rejects a legacy macro cache that would render zero panels beside populated cards", () => {
+    expect(
+      hasReconciledMacroDistributions(
+        cachedFirstFold(
+          { entityCount: 66, statusCount: 0, classificationCount: 0 },
+          { entityCount: 16, statusCount: 0, classificationCount: 0 },
+        ),
+      ),
+    ).toBe(false);
+  });
+
+  it("accepts fully reconciled SPEC and PRD panels", () => {
+    expect(
+      hasReconciledMacroDistributions(
+        cachedFirstFold(
+          { entityCount: 66, statusCount: 66, classificationCount: 66 },
+          { entityCount: 16, statusCount: 16, classificationCount: 16 },
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it("rejects malformed legacy count maps before summing them", () => {
+    const legacy = cachedFirstFold(
+      { entityCount: 1, statusCount: 1, classificationCount: 1 },
+      { entityCount: 1, statusCount: 1, classificationCount: 1 },
+    ) as unknown as { macro_metrics: { specs: { status_counts: unknown } } };
+    legacy.macro_metrics.specs.status_counts = undefined;
+
+    expect(hasReconciledMacroDistributions(legacy as unknown as SqliteFirstFoldAllTime)).toBe(
+      false,
+    );
+  });
+
+  it("recomputes a persisted legacy payload whose macro panels are missing", () => {
+    const database = new DatabaseSync(":memory:");
+    try {
+      database.exec(`
+        CREATE TABLE zaip_aios_activities (payload_type TEXT, payload_json TEXT, recorded_at TEXT);
+        INSERT INTO zaip_aios_activities VALUES ('first_fold_all_time_cache', '{"aggregate":{}}', '2026-09-15T00:00:00.000Z');
+        CREATE VIEW zaip_vw_first_fold_overview_all_time AS SELECT 0 AS task_count, 0 AS completed_task_count, 1 AS spec_count, 0 AS completed_spec_count, 1 AS prd_count, 0 AS completed_prd_count, 0 AS total_run_count, 0 AS agent_invocation_count, NULL AS llm_call_count, NULL AS total_duration_ms, NULL AS total_tokens, NULL AS total_cost_usd, NULL AS total_cost_brl, 0 AS execution_day_count, NULL AS latest_task_created_at, NULL AS start_day, NULL AS end_day;
+        CREATE VIEW zaip_vw_first_fold_task_status_all_time AS SELECT 'draft' AS status, 0 AS task_count WHERE 0;
+        CREATE VIEW zaip_vw_first_fold_task_risk_all_time AS SELECT 'standard' AS risk, 0 AS task_count WHERE 0;
+        CREATE VIEW zaip_vw_first_fold_top_tasks_all_time AS SELECT 1 AS rank WHERE 0;
+        CREATE VIEW zaip_vw_first_fold_task_metrics_all_time AS SELECT NULL AS average_duration_ms_per_task, NULL AS average_tokens_per_task, NULL AS average_cost_usd_per_task, NULL AS average_cost_brl_per_task, NULL AS latest_task_created_at;
+        CREATE VIEW zaip_vw_first_fold_spec_status_all_time AS SELECT 'executing' AS stage, 1 AS entity_count;
+        CREATE VIEW zaip_vw_first_fold_prd_status_all_time AS SELECT 'executing' AS stage, 1 AS entity_count;
+        CREATE VIEW zaip_vw_first_fold_spec_classification_all_time AS SELECT 'structured' AS classification, 1 AS entity_count;
+        CREATE VIEW zaip_vw_first_fold_prd_classification_all_time AS SELECT 'structured' AS classification, 1 AS entity_count;
+        CREATE VIEW zaip_vw_first_fold_spec_metrics_all_time AS SELECT 1 AS entity_count, 0 AS total_run_count, NULL AS total_duration_ms, NULL AS total_tokens, NULL AS total_cost_usd, NULL AS total_cost_brl, NULL AS average_duration_ms, NULL AS average_tokens, NULL AS average_cost_usd, NULL AS average_cost_brl, NULL AS latest_created_at;
+        CREATE VIEW zaip_vw_first_fold_prd_metrics_all_time AS SELECT 1 AS entity_count, 0 AS total_run_count, NULL AS total_duration_ms, NULL AS total_tokens, NULL AS total_cost_usd, NULL AS total_cost_brl, NULL AS average_duration_ms, NULL AS average_tokens, NULL AS average_cost_usd, NULL AS average_cost_brl, NULL AS latest_created_at;
+        CREATE VIEW zaip_vw_first_fold_top_specs_all_time AS SELECT 1 AS rank WHERE 0;
+        CREATE VIEW zaip_vw_first_fold_top_prds_all_time AS SELECT 1 AS rank WHERE 0;
+      `);
+      const rebuilt = readFirstFoldAllTime(database, () => 0);
+
+      expect(rebuilt.macro_metrics.specs).toMatchObject({
+        entity_count: 1,
+        status_counts: { executing: 1 },
+        classification_counts: { structured: 1 },
+      });
+      expect(rebuilt.macro_metrics.prds.entity_count).toBe(1);
+    } finally {
+      database.close();
+    }
+  });
+});