@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-work-list.test.ts

@@ -0,0 +1,223 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import {
+  attachOperationsWorkListDevelopers,
+  operationsWorkListPayloadPage,
+  operationsWorkListSql,
+} from "./sqlite-operations-work-list.js";
+
+function page(input: Parameters<typeof operationsWorkListSql>[0]) {
+  const database = new DatabaseSync(":memory:");
+  database.exec(`
+    CREATE TABLE canonical_work_items (entity_kind TEXT, id TEXT, stage TEXT, risk TEXT, spec_id TEXT, change_id TEXT, occurred_day_sp TEXT);
+    CREATE TABLE canonical_changes (id TEXT, source_type TEXT, task_ids_json TEXT, created_at TEXT);
+    CREATE TABLE operations_work_kanban (entity_kind TEXT, id TEXT, title TEXT, status TEXT, risk TEXT, occurred_at TEXT, occurred_day_sp TEXT);
+    INSERT INTO canonical_work_items VALUES
+      ('task','TASK-PRD','executing','standard','SPEC-1','CHG-PRD','2026-08-01'),
+      ('task','TASK-SPEC','ready','standard','SPEC-1',NULL,'2026-08-02'),
+      ('task','TASK-STANDALONE','executing','standard',NULL,NULL,'2026-08-03'),
+      ('task','TASK-ORIGIN-SPEC','ready','standard',NULL,'CHG-SPEC','2026-08-03'),
+      ('prd','PRD-1','definition','standard',NULL,NULL,'2026-08-04'),
+      ('spec','SPEC-1','planning','standard',NULL,NULL,'2026-08-05');
+    INSERT INTO operations_work_kanban SELECT entity_kind,id,id,'active',risk,occurred_day_sp || 'T00:00:00Z',occurred_day_sp FROM canonical_work_items;
+    INSERT INTO canonical_changes VALUES
+      ('CHG-PRD','prd','["TASK-PRD"]','2026-08-04T00:00:00Z'),
+      ('CHG-SPEC','spec','["TASK-ORIGIN-SPEC"]','2026-08-04T00:00:00Z'),
+      ('CHG-NEWER','spec','["TASK-PRD"]','2026-08-05T00:00:00Z');
+  `);
+  const sql = operationsWorkListSql(input);
+  const rows = database
+    .prepare(`${sql.select} FROM ${sql.source}${sql.where} ORDER BY work.id`)
+    .all(...sql.values) as Array<Record<string, unknown>>;
+  database.close();
+  return rows;
+}
+
+describe("operations work list SQL", () => {
+  it("matches Kanban task kind and Change-origin precedence", () => {
+    expect(page({ kind: "all-tasks" }).map((row) => row.id)).toEqual([
+      "TASK-ORIGIN-SPEC",
+      "TASK-PRD",
+      "TASK-SPEC",
+      "TASK-STANDALONE",
+    ]);
+    expect(page({ kind: "task" }).map((row) => row.id)).toEqual([
+      "TASK-ORIGIN-SPEC",
+      "TASK-PRD",
+      "TASK-SPEC",
+    ]);
+    expect(page({ kind: "standalone-task" }).map((row) => row.id)).toEqual(["TASK-STANDALONE"]);
+    expect(page({ origin: "prd" }).map((row) => row.id)).toEqual(["TASK-PRD"]);
+    expect(page({ origin: "spec" }).map((row) => row.id)).toEqual([
+      "TASK-ORIGIN-SPEC",
+      "TASK-SPEC",
+    ]);
+    expect(page({ origin: "task" }).map((row) => row.id)).toEqual(["TASK-STANDALONE"]);
+  });
+
+  it("filters the public WorkStage, independent of lifecycle status", () => {
+    expect(page({ status: "executing", kind: "all" }).map((row) => row.id)).toEqual([
+      "TASK-PRD",
+      "TASK-STANDALONE",
+    ]);
+  });
+
+  it("paginates complete all-time payloads with public kinds and filters", () => {
+    const payload = {
+      pages: {
+        task: [
+          {
+            id: "TASK-LINKED",
+            title: "Linked task",
+            stage: "executing",
+            risk: "standard",
+            origin: "spec",
+            spec_id: "SPEC-1",
+            occurred_at: "2026-08-03T00:00:00Z",
+          },
+          {
+            id: "TASK-STANDALONE",
+            title: "Standalone task",
+            stage: "ready",
+            risk: "lite",
+            origin: "task",
+            spec_id: null,
+            occurred_at: "2026-08-02T00:00:00Z",
+          },
+        ],
+        spec: [
+          {
+            id: "SPEC-1",
+            title: "Specification",
+            stage: "planning",
+            risk: "standard",
+            occurred_at: "2026-08-04T00:00:00Z",
+          },
+        ],
+        prd: [
+          {
+            id: "PRD-1",
+            title: "Product requirement",
+            stage: "definition",
+            risk: "critical",
+            occurred_at: "2026-08-05T00:00:00Z",
+          },
+        ],
+      },
+    };
+    expect(operationsWorkListPayloadPage({ kind: "all", limit: 2 }, payload)).toMatchObject({
+      total_count: 4,
+      has_more: true,
+      rows: [
+        { id: "PRD-1", kind: "prd" },
+        { id: "SPEC-1", kind: "spec" },
+      ],
+    });
+    expect(
+      operationsWorkListPayloadPage({ kind: "all", offset: 2, limit: 2 }, payload)?.rows.map(
+        (row) => row.id,
+      ),
+    ).toEqual(["TASK-LINKED", "TASK-STANDALONE"]);
+    expect(
+      operationsWorkListPayloadPage({ kind: "task", status: "executing", origin: "spec" }, payload)
+        ?.rows,
+    ).toMatchObject([{ id: "TASK-LINKED", kind: "task" }]);
+    expect(
+      operationsWorkListPayloadPage({ kind: "standalone-task", risk: "lite" }, payload)?.rows,
+    ).toMatchObject([{ id: "TASK-STANDALONE", kind: "standalone-task" }]);
+    expect(
+      operationsWorkListPayloadPage({ kind: "all-tasks" }, payload)?.rows.map((row) => row.id),
+    ).toEqual(["TASK-LINKED", "TASK-STANDALONE"]);
+    expect(
+      operationsWorkListPayloadPage({ kind: "prd", query: "product" }, payload)?.rows,
+    ).toMatchObject([{ id: "PRD-1", kind: "prd" }]);
+    expect(operationsWorkListPayloadPage({ kind: "all" }, {})).toBeNull();
+  });
+
+  it("accepts the validated default-month payload but never applies all-time data to a range", () => {
+    const month = {
+      from_day: "2026-08-01",
+      to_day: "2026-08-31",
+      pages: { task: [], spec: [], prd: [] },
+    };
+    expect(
+      operationsWorkListPayloadPage({ from: "2026-08-01", to: "2026-08-31" }, month),
+    ).toMatchObject({
+      total_count: 0,
+    });
+    expect(
+      operationsWorkListPayloadPage(
+        { from: "2026-08-01", to: "2026-08-31" },
+        { pages: month.pages },
+      ),
+    ).toBeNull();
+  });
+
+  it("retains more than 200 rows for exports and later pages", () => {
+    const task = Array.from({ length: 205 }, (_, index) => ({
+      id: `TASK-${String(index).padStart(3, "0")}`,
+      title: "Complete population",
+      stage: "ready",
+      risk: "standard",
+      origin: "spec",
+      occurred_at: `2026-08-${String((index % 28) + 1).padStart(2, "0")}T00:00:00Z`,
+    }));
+    const payload = { pages: { task, spec: [], prd: [] } };
+    const firstPage = operationsWorkListPayloadPage({ kind: "task", limit: 100 }, payload);
+    expect(firstPage).toMatchObject({
+      total_count: 205,
+      has_more: true,
+    });
+    expect(firstPage?.rows).toHaveLength(100);
+    expect(firstPage?.rows.map((row) => row.id)).toContain("TASK-195");
+    expect(
+      operationsWorkListPayloadPage({ kind: "task", offset: 200, limit: 100 }, payload),
+    ).toMatchObject({ total_count: 205, has_more: false, rows: expect.any(Array) });
+    expect(
+      operationsWorkListPayloadPage({ kind: "task", offset: 200, limit: 100 }, payload)?.rows,
+    ).toHaveLength(5);
+  });
+
+  it("projects each page's factual developer identities in one period-bounded set", () => {
+    const database = new DatabaseSync(":memory:");
+    database.exec(`
+      CREATE TABLE zaip_aios_activities (
+        payload_type TEXT, task_id TEXT, spec_id TEXT, prd_id TEXT,
+        developer_account_id TEXT, developer_login TEXT, occurred_day_sp TEXT
+      );
+      INSERT INTO zaip_aios_activities VALUES
+        (NULL, 'TASK-1', NULL, NULL, '2', 'alpha', '2026-08-10'),
+        (NULL, 'TASK-1', NULL, NULL, '2', 'beta', '2026-08-10'),
+        (NULL, 'TASK-1', NULL, NULL, '10', NULL, '2026-08-10'),
+        (NULL, 'TASK-1', NULL, NULL, 'outside-period', 'ignored', '2026-08-09'),
+        (NULL, NULL, 'SPEC-1', NULL, '7', 'spec-dev', '2026-08-10'),
+        (NULL, NULL, NULL, 'PRD-NOT-ON-PAGE', '99', 'not-selected', '2026-08-10');
+    `);
+    const rows = attachOperationsWorkListDevelopers(
+      database,
+      [
+        { id: "TASK-1", kind: "task" },
+        { id: "SPEC-1", entity_kind: "spec" },
+        { id: "TASK-WITHOUT-RUN", kind: "standalone-task" },
+      ],
+      { from: "2026-08-10", to: "2026-08-10" },
+    );
+    expect(rows).toEqual([
+      {
+        id: "TASK-1",
+        kind: "task",
+        developers: [
+          { account_id: "10", login_snapshot: null },
+          { account_id: "2", login_snapshot: "beta" },
+        ],
+      },
+      {
+        id: "SPEC-1",
+        entity_kind: "spec",
+        developers: [{ account_id: "7", login_snapshot: "spec-dev" }],
+      },
+      { id: "TASK-WITHOUT-RUN", kind: "standalone-task", developers: [] },
+    ]);
+    database.close();
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-work-list.ts

@@ -0,0 +1,304 @@
+import type { DatabaseSync } from "node:sqlite";
+
+export type OperationsWorkListQuery = {
+  from?: string | null;
+  to?: string | null;
+  query?: string;
+  status?: string;
+  risk?: string;
+  origin?: string;
+  kind?: "all" | "all-tasks" | "task" | "standalone-task" | "prd" | "spec";
+};
+
+type WorkRow = Record<string, unknown>;
+type WorkPagesPayload = { pages: { task: WorkRow[]; spec: WorkRow[]; prd: WorkRow[] } };
+
+export type OperationsWorkListDeveloper = {
+  account_id: string;
+  login_snapshot: string | null;
+};
+
+export type OperationsWorkListPayloadPage = {
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  rows: WorkRow[];
+};
+
+function isWorkPagesPayload(value: unknown): value is WorkPagesPayload {
+  if (value === null || typeof value !== "object") return false;
+  const pages = (value as { pages?: unknown }).pages;
+  if (pages === null || typeof pages !== "object") return false;
+  return ["task", "spec", "prd"].every((kind) =>
+    Array.isArray((pages as Record<string, unknown>)[kind]),
+  );
+}
+
+function publicKind(row: WorkRow, sourceKind: "task" | "spec" | "prd") {
+  if (sourceKind !== "task") return sourceKind;
+  if (row.kind === "task" || row.kind === "standalone-task") return row.kind;
+  return (typeof row.spec_id === "string" && row.spec_id.length > 0) ||
+    row.origin === "spec" ||
+    row.origin === "prd"
+    ? "task"
+    : "standalone-task";
+}
+
+function matchesPayloadFilter(row: WorkRow, kind: string, input: OperationsWorkListQuery): boolean {
+  if (input.kind && input.kind !== "all") {
+    const matchesKind =
+      input.kind === "all-tasks"
+        ? kind === "task" || kind === "standalone-task"
+        : kind === input.kind;
+    if (!matchesKind) return false;
+  }
+  if (input.query) {
+    const query = input.query.toLowerCase();
+    if (
+      !String(row.id ?? "")
+        .toLowerCase()
+        .includes(query) &&
+      !String(row.title ?? "")
+        .toLowerCase()
+        .includes(query)
+    )
+      return false;
+  }
+  if (input.status && row.stage !== input.status) return false;
+  if (input.risk && row.risk !== input.risk) return false;
+  // SQL only permits origin filters for Tasks. If an older payload lacks the
+  // persisted origin, preserve factual parity by falling back to SQL instead.
+  if (input.origin && (kind === "prd" || kind === "spec" || typeof row.origin !== "string"))
+    return false;
+  if (input.origin && row.origin !== input.origin) return false;
+  return true;
+}
+
+/**
+ * Paginates already-materialized Board pages. Returning null deliberately
+ * delegates to SQL when a payload is absent or not rich enough for a filter.
+ */
+export function operationsWorkListPayloadPage(
+  input: OperationsWorkListQuery & { offset?: number; limit?: number },
+  payload: unknown,
+): OperationsWorkListPayloadPage | null {
+  if (!isWorkPagesPayload(payload)) return null;
+  if (input.from || input.to) {
+    // Monthly payload eligibility is established by readFirstFoldMonthlyQuick;
+    // all-time payload callers do not provide a temporal filter.
+    const hasRange = typeof (payload as { from_day?: unknown }).from_day === "string";
+    if (!hasRange) return null;
+  }
+  const rows = (["task", "spec", "prd"] as const)
+    .flatMap((sourceKind) =>
+      payload.pages[sourceKind].map(
+        (row): WorkRow => ({ ...row, kind: publicKind(row, sourceKind) }),
+      ),
+    )
+    .filter((row) => matchesPayloadFilter(row, String(row.kind), input))
+    .sort(
+      (left, right) =>
+        String(right.occurred_at ?? "").localeCompare(String(left.occurred_at ?? "")) ||
+        String(right.id ?? "").localeCompare(String(left.id ?? "")),
+    );
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const page = rows.slice(offset, offset + limit);
+  return {
+    offset,
+    limit,
+    total_count: rows.length,
+    has_more: offset + page.length < rows.length,
+    rows: page,
+  };
+}
+
+const linkedToSpec = "canonical.spec_id IS NOT NULL";
+const changeId = `(COALESCE(canonical.change_id, (SELECT change.id FROM canonical_changes change, json_each(change.task_ids_json) task WHERE task.value = canonical.id ORDER BY change.created_at DESC, change.id DESC LIMIT 1)))`;
+const changeOrigin = `(SELECT change.source_type FROM canonical_changes change WHERE change.id=${changeId})`;
+const linkedTask = `(${linkedToSpec} OR COALESCE(${changeOrigin} IN ('spec', 'prd'), 0))`;
+
+/** Builds count/page SQL for the canonical, server-paginated Operations List. */
+export function operationsWorkListSql(input: OperationsWorkListQuery) {
+  const clauses: string[] = [];
+  const values: Array<string | number> = [];
+  if (input.from) {
+    clauses.push("canonical.occurred_day_sp >= ?");
+    values.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    clauses.push("canonical.occurred_day_sp <= ?");
+    values.push(input.to.slice(0, 10));
+  }
+  if (input.query) {
+    clauses.push("(work.id LIKE ? OR work.title LIKE ?)");
+    values.push(`%${input.query}%`, `%${input.query}%`);
+  }
+  if (input.status) {
+    clauses.push("canonical.stage = ?");
+    values.push(input.status);
+  }
+  if (input.risk) {
+    clauses.push("canonical.risk = ?");
+    values.push(input.risk);
+  }
+  if (input.origin) {
+    clauses.push("canonical.entity_kind = 'task'");
+    const fallback =
+      input.origin === "spec"
+        ? linkedToSpec
+        : input.origin === "task"
+          ? `NOT ${linkedToSpec}`
+          : "0";
+    clauses.push(`(${changeOrigin} = ? OR (${changeOrigin} IS NULL AND ${fallback}))`);
+    values.push(input.origin);
+  }
+  if (input.kind === "prd" || input.kind === "spec") {
+    clauses.push("canonical.entity_kind = ?");
+    values.push(input.kind);
+  } else if (
+    input.kind === "all-tasks" ||
+    input.kind === "task" ||
+    input.kind === "standalone-task"
+  ) {
+    clauses.push("canonical.entity_kind = 'task'");
+    if (input.kind !== "all-tasks")
+      clauses.push(input.kind === "task" ? linkedTask : `NOT ${linkedTask}`);
+  }
+  const source =
+    "operations_work_kanban work JOIN canonical_work_items canonical ON canonical.entity_kind=work.entity_kind AND canonical.id=work.id";
+  return {
+    source,
+    where: clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`,
+    values,
+    select: `SELECT work.*, canonical.stage, canonical.spec_id,
+      ${changeId} AS change_id, ${changeOrigin} AS origin,
+      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN ${linkedTask} THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind`,
+  };
+}
+
+export function operationsWorkListSqlPage(
+  database: DatabaseSync,
+  input: OperationsWorkListQuery & { offset?: number; limit?: number },
+): OperationsWorkListPayloadPage {
+  const page = operationsWorkListSql(input);
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const total_count = Number(
+    (
+      database
+        .prepare(`SELECT COUNT(*) AS count FROM ${page.source}${page.where}`)
+        .get(...page.values) as {
+        count: number;
+      }
+    ).count,
+  );
+  const rows = database
+    .prepare(
+      `${page.select} FROM ${page.source}${page.where} ORDER BY work.occurred_at DESC, work.id DESC LIMIT ? OFFSET ?`,
+    )
+    .all(...page.values, limit, offset) as WorkRow[];
+  return { offset, limit, total_count, has_more: offset + rows.length < total_count, rows };
+}
+
+function workEntityKind(row: WorkRow): "task" | "spec" | "prd" | null {
+  const kind = row.entity_kind ?? row.kind;
+  if (kind === "task" || kind === "standalone-task") return "task";
+  if (kind === "spec" || kind === "prd") return kind;
+  return null;
+}
+
+/** Adds factual developer identities for only the Work List page IDs. */
+export function attachOperationsWorkListDevelopers(
+  database: DatabaseSync,
+  rows: readonly WorkRow[],
+  input: Pick<OperationsWorkListQuery, "from" | "to">,
+): WorkRow[] {
+  const pageItems = rows.flatMap((row) => {
+    const entityKind = workEntityKind(row);
+    const id = typeof row.id === "string" && row.id.length > 0 ? row.id : null;
+    return entityKind && id ? [{ entityKind, id }] : [];
+  });
+  if (pageItems.length === 0) return rows.map((row) => ({ ...row, developers: [] }));
+
+  const values = pageItems.flatMap(({ entityKind, id }) => [entityKind, id]);
+  const from = input.from?.slice(0, 10) ?? null;
+  const to = input.to?.slice(0, 10) ?? null;
+  const identities = database
+    .prepare(
+      `WITH page_items(entity_kind, id) AS (VALUES ${pageItems.map(() => "(?, ?)").join(", ")}),
+      identified_developers AS (
+        SELECT page_items.entity_kind, page_items.id,
+          CAST(activity.developer_account_id AS TEXT) AS account_id,
+          MAX(NULLIF(TRIM(activity.developer_login), '')) AS login_snapshot
+        FROM page_items
+        JOIN zaip_aios_activities activity
+          ON activity.payload_type IS NULL
+          AND activity.developer_account_id IS NOT NULL
+          AND TRIM(activity.developer_account_id) <> ''
+          AND (
+            (page_items.entity_kind='task' AND activity.task_id=page_items.id)
+            OR (page_items.entity_kind='spec' AND activity.spec_id=page_items.id)
+            OR (page_items.entity_kind='prd' AND activity.prd_id=page_items.id)
+          )
+        WHERE (? IS NULL OR activity.occurred_day_sp >= ?)
+          AND (? IS NULL OR activity.occurred_day_sp <= ?)
+        GROUP BY page_items.entity_kind, page_items.id, CAST(activity.developer_account_id AS TEXT)
+      )
+      SELECT entity_kind, id, account_id, login_snapshot
+      FROM identified_developers
+      ORDER BY entity_kind, id, account_id COLLATE BINARY`,
+    )
+    .all(...values, from, from, to, to) as Array<{
+    entity_kind: "task" | "spec" | "prd";
+    id: string;
+    account_id: string;
+    login_snapshot: string | null;
+  }>;
+  const developersByItem = new Map<string, OperationsWorkListDeveloper[]>();
+  for (const identity of identities) {
+    const key = `${identity.entity_kind}:${identity.id}`;
+    const developers = developersByItem.get(key) ?? [];
+    developers.push({ account_id: identity.account_id, login_snapshot: identity.login_snapshot });
+    developersByItem.set(key, developers);
+  }
+  return rows.map((row) => {
+    const entityKind = workEntityKind(row);
+    const id = typeof row.id === "string" ? row.id : "";
+    return {
+      ...row,
+      developers: entityKind ? (developersByItem.get(`${entityKind}:${id}`) ?? []) : [],
+    };
+  });
+}
+
+/** One physical expansion used only while materializing first-fold payloads. */
+export function operationsWorkListSqlRows(database: DatabaseSync): WorkRow[] {
+  const physical = database
+    .prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='operations_work_projection' LIMIT 1",
+    )
+    .get();
+  if (physical !== undefined)
+    return database
+      .prepare("SELECT * FROM operations_work_projection ORDER BY occurred_at DESC, id DESC")
+      .all() as WorkRow[];
+  const page = operationsWorkListSql({ kind: "all" });
+  return database
+    .prepare(
+      `${page.select} FROM ${page.source}${page.where} ORDER BY work.occurred_at DESC, work.id DESC`,
+    )
+    .all(...page.values) as WorkRow[];
+}
+
+export function operationsWorkRowsInRange(
+  rows: readonly WorkRow[],
+  from: string,
+  to: string,
+): WorkRow[] {
+  return rows.filter((row) => {
+    const day = typeof row.occurred_day_sp === "string" ? row.occurred_day_sp : "";
+    return day >= from && day <= to;
+  });
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-cache.test-support.ts

@@ -0,0 +1,23 @@
+import { resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect } from "vitest";
+
+export function expectPersistedFirstFoldCaches(root: string, allTime: unknown, board: unknown) {
+  const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    readOnly: true,
+  });
+  try {
+    const read = (payloadType: string) =>
+      database
+        .prepare("SELECT payload_json FROM zaip_aios_activities WHERE payload_type=?")
+        .get(payloadType) as { payload_json: string } | undefined;
+    const persistedAllTime = read("first_fold_all_time_cache");
+    const persistedBoard = read("first_fold_all_time_board_cache");
+    expect(persistedAllTime).toBeDefined();
+    expect(persistedBoard).toBeDefined();
+    expect(JSON.parse(persistedAllTime!.payload_json)).toEqual(allTime);
+    expect(JSON.parse(persistedBoard!.payload_json)).toEqual(board);
+  } finally {
+    database.close();
+  }
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-first-fold-types.ts

@@ -0,0 +1,89 @@
+import type { SqliteFirstFoldAggregate, SqliteSummaryKind } from "./sqlite-read-model.js";
+
+export type SqliteFirstFoldAllTime = {
+  aggregate: SqliteFirstFoldAggregate & {
+    start_day: string | null;
+    end_day: string | null;
+    task_count: number;
+    completed_task_count: number;
+    spec_count: number;
+    completed_spec_count: number;
+    prd_count: number;
+    completed_prd_count: number;
+    total_cost_usd: number | null;
+    latest_task_created_at: string | null;
+  };
+  task_status_counts: Record<string, number>;
+  task_risk_counts: Record<string, number>;
+  task_metrics: {
+    average_duration_ms_per_task: number | null;
+    average_tokens_per_task: number | null;
+    average_cost_usd_per_task: number | null;
+    average_cost_brl_per_task: number | null;
+    latest_task_created_at: string | null;
+  };
+  top_tasks: Array<{
+    rank: number;
+    task_id: string;
+    title: string;
+    status: string | null;
+    risk: string | null;
+    total_run_count: number;
+    llm_call_count: number | null;
+    total_duration_ms: number;
+    total_tokens: number | null;
+    total_cost_usd: number | null;
+    total_cost_brl: number | null;
+    duration_share: number;
+  }>;
+  macro_metrics: Record<
+    "specs" | "prds",
+    {
+      status_counts: Record<string, number>;
+      classification_counts: Record<string, number>;
+      entity_count: number;
+      total_run_count: number;
+      total_duration_ms: number | null;
+      total_tokens: number | null;
+      total_cost_usd: number | null;
+      total_cost_brl: number | null;
+      average_duration_ms: number | null;
+      average_tokens: number | null;
+      average_cost_usd: number | null;
+      average_cost_brl: number | null;
+      latest_created_at: string | null;
+      top_entities: Array<{
+        rank: number;
+        entity_id: string;
+        title: string;
+        status: string | null;
+        total_run_count: number;
+        llm_call_count: number | null;
+        total_duration_ms: number | null;
+        total_tokens: number | null;
+        total_cost_usd: number | null;
+        total_cost_brl: number | null;
+        duration_share: number;
+      }>;
+    }
+  >;
+};
+
+export type SqliteFirstFoldMonthlyQuick = {
+  from_day: string;
+  to_day: string;
+  source_latest_day: string | null;
+  aggregate: SqliteFirstFoldAggregate;
+  pages: Record<SqliteSummaryKind, Array<Record<string, unknown>>>;
+  top_tasks: Array<{
+    task_id: string;
+    total_tokens: number | null;
+    cost_brl: number | null;
+    run_count: number;
+    duration_ms: number;
+  }>;
+};
+
+export type SqliteFirstFoldAllTimeBoard = {
+  pages: Record<SqliteSummaryKind, Array<Record<string, unknown>>>;
+};