@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -0,0 +1,355 @@
+import type { DatabaseSync } from "node:sqlite";
+import { measureFirstFoldQuery } from "./sqlite-first-fold-timing.js";
+import type {
+  SqliteFirstFoldAllTime,
+  SqliteFirstFoldAllTimeBoard,
+  SqliteFirstFoldMonthlyQuick,
+  SqliteFirstFoldViewport,
+} from "./sqlite-read-model.js";
+
+const number = (value: unknown, fallback = 0) => (typeof value === "number" ? value : fallback);
+const nullableNumber = (value: unknown) => (typeof value === "number" ? value : null);
+
+function persisted<T>(database: DatabaseSync, payloadType: string): T | null {
+  const row = database
+    .prepare(
+      "SELECT payload_json FROM zaip_aios_activities WHERE payload_type=? ORDER BY recorded_at DESC LIMIT 1",
+    )
+    .get(payloadType) as { payload_json?: string } | undefined;
+  if (typeof row?.payload_json !== "string") return null;
+  try {
+    return JSON.parse(row.payload_json) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function readFirstFoldAllTime(
+  database: DatabaseSync,
+  dailyAggregateCount: () => number,
+  viewport?: SqliteFirstFoldViewport,
+): SqliteFirstFoldAllTime {
+  const cached = persisted<SqliteFirstFoldAllTime>(database, "first_fold_all_time_cache");
+  if (cached !== null) return cached;
+  const timed = <T>(phase: string, action: () => T) => measureFirstFoldQuery(phase, action);
+  const row =
+    viewport === undefined
+      ? (database.prepare("SELECT * FROM zaip_vw_first_fold_overview_all_time").get() as Record<
+          string,
+          unknown
+        >)
+      : null;
+  const statusRows =
+    viewport === undefined
+      ? (database
+          .prepare("SELECT status, task_count FROM zaip_vw_first_fold_task_status_all_time")
+          .all() as Array<{ status: string; task_count: number }>)
+      : null;
+  const riskRows =
+    viewport === undefined
+      ? (database
+          .prepare("SELECT risk, task_count FROM zaip_vw_first_fold_task_risk_all_time")
+          .all() as Array<{ risk: string; task_count: number }>)
+      : null;
+  const topTasks = timed(
+    "first_fold_all_time_top_tasks",
+    () =>
+      database
+        .prepare("SELECT * FROM zaip_vw_first_fold_top_tasks_all_time ORDER BY rank")
+        .all() as SqliteFirstFoldAllTime["top_tasks"],
+  );
+  const readMacroMetrics = (kind: "spec" | "prd") => {
+    const statuses = timed(
+      `first_fold_${kind}_status`,
+      () =>
+        database
+          .prepare(`SELECT stage, entity_count FROM zaip_vw_first_fold_${kind}_status_all_time`)
+          .all() as Array<{ stage: string; entity_count: number }>,
+    );
+    const classifications = timed(
+      `first_fold_${kind}_classification`,
+      () =>
+        database
+          .prepare(
+            `SELECT classification, entity_count FROM zaip_vw_first_fold_${kind}_classification_all_time`,
+          )
+          .all() as Array<{ classification: string; entity_count: number }>,
+    );
+    const macro = timed(
+      `first_fold_${kind}_metrics`,
+      () =>
+        database
+          .prepare(`SELECT * FROM zaip_vw_first_fold_${kind}_metrics_all_time`)
+          .get() as Record<string, unknown>,
+    );
+    const topEntities = timed(
+      `first_fold_${kind}_top_entities`,
+      () =>
+        database
+          .prepare(`SELECT * FROM zaip_vw_first_fold_top_${kind}s_all_time ORDER BY rank`)
+          .all() as SqliteFirstFoldAllTime["macro_metrics"]["specs"]["top_entities"],
+    );
+    return {
+      status_counts: Object.fromEntries(
+        statuses.map((status) => [status.stage, Number(status.entity_count)]),
+      ),
+      classification_counts: Object.fromEntries(
+        classifications.map((item) => [item.classification, Number(item.entity_count)]),
+      ),
+      entity_count: number(macro.entity_count),
+      total_run_count: number(macro.total_run_count),
+      total_duration_ms: nullableNumber(macro.total_duration_ms),
+      total_tokens: nullableNumber(macro.total_tokens),
+      total_cost_usd: nullableNumber(macro.total_cost_usd),
+      total_cost_brl: nullableNumber(macro.total_cost_brl),
+      average_duration_ms: nullableNumber(macro.average_duration_ms),
+      average_tokens: nullableNumber(macro.average_tokens),
+      average_cost_usd: nullableNumber(macro.average_cost_usd),
+      average_cost_brl: nullableNumber(macro.average_cost_brl),
+      latest_created_at:
+        typeof macro.latest_created_at === "string" ? macro.latest_created_at : null,
+      top_entities: topEntities,
+    };
+  };
+  return {
+    aggregate: viewport?.aggregate ?? {
+      days:
+        typeof row?.start_day === "string" && typeof row.end_day === "string"
+          ? dailyAggregateCount()
+          : 0,
+      start_day: typeof row?.start_day === "string" ? row.start_day : null,
+      end_day: typeof row?.end_day === "string" ? row.end_day : null,
+      task_count: number(row?.task_count),
+      completed_task_count: number(row?.completed_task_count),
+      spec_count: number(row?.spec_count),
+      completed_spec_count: number(row?.completed_spec_count),
+      prd_count: number(row?.prd_count),
+      completed_prd_count: number(row?.completed_prd_count),
+      total_run_count: number(row?.total_run_count),
+      agent_invocation_count: number(row?.agent_invocation_count),
+      llm_call_count: nullableNumber(row?.llm_call_count),
+      duration_ms: nullableNumber(row?.total_duration_ms),
+      total_tokens: nullableNumber(row?.total_tokens),
+      total_cost_usd: nullableNumber(row?.total_cost_usd),
+      cost_brl: nullableNumber(row?.total_cost_brl),
+      execution_day_count: number(row?.execution_day_count),
+      latest_task_created_at:
+        typeof row?.latest_task_created_at === "string" ? row.latest_task_created_at : null,
+    },
+    task_status_counts:
+      viewport?.task_status_counts ??
+      Object.fromEntries(
+        statusRows?.map((status) => [status.status, Number(status.task_count)]) ?? [],
+      ),
+    task_risk_counts:
+      viewport?.task_risk_counts ??
+      Object.fromEntries(riskRows?.map((risk) => [risk.risk, Number(risk.task_count)]) ?? []),
+    task_metrics: viewport
+      ? {
+          average_duration_ms_per_task:
+            viewport.aggregate.task_count === 0 || viewport.aggregate.duration_ms === null
+              ? null
+              : viewport.aggregate.duration_ms / viewport.aggregate.task_count,
+          average_tokens_per_task:
+            viewport.aggregate.task_count === 0 || viewport.aggregate.total_tokens === null
+              ? null
+              : viewport.aggregate.total_tokens / viewport.aggregate.task_count,
+          average_cost_usd_per_task:
+            viewport.aggregate.task_count === 0 || viewport.aggregate.total_cost_usd === null
+              ? null
+              : viewport.aggregate.total_cost_usd / viewport.aggregate.task_count,
+          average_cost_brl_per_task:
+            viewport.aggregate.task_count === 0 || viewport.aggregate.cost_brl === null
+              ? null
+              : viewport.aggregate.cost_brl / viewport.aggregate.task_count,
+          latest_task_created_at: viewport.aggregate.latest_task_created_at,
+        }
+      : (() => {
+          const metrics = database
+            .prepare("SELECT * FROM zaip_vw_first_fold_task_metrics_all_time")
+            .get() as Record<string, unknown>;
+          return {
+            average_duration_ms_per_task: nullableNumber(metrics.average_duration_ms_per_task),
+            average_tokens_per_task: nullableNumber(metrics.average_tokens_per_task),
+            average_cost_usd_per_task: nullableNumber(metrics.average_cost_usd_per_task),
+            average_cost_brl_per_task: nullableNumber(metrics.average_cost_brl_per_task),
+            latest_task_created_at:
+              typeof metrics.latest_task_created_at === "string"
+                ? metrics.latest_task_created_at
+                : null,
+          };
+        })(),
+    top_tasks: topTasks,
+    macro_metrics: { specs: readMacroMetrics("spec"), prds: readMacroMetrics("prd") },
+  };
+}
+
+export function readFirstFoldViewport(
+  database: DatabaseSync,
+  timings: Record<string, number>,
+): SqliteFirstFoldViewport {
+  const cached = persisted<SqliteFirstFoldViewport>(database, "first_fold_viewport_cache");
+  if (cached !== null) return cached;
+  const startedAt = performance.now();
+  const row = database
+    .prepare(`WITH totals AS (
+    SELECT SUM(CASE WHEN activity_source_kind='agent_run' THEN 1 ELSE 0 END) AS agent_invocation_count,
+      SUM(llm_call_count) AS llm_call_count, SUM(total_tokens) AS total_tokens,
+      SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM activities
+  ), run_totals AS (SELECT COUNT(*) AS total_run_count FROM canonical_run_index),
+  duration_totals AS (
+    SELECT ROUND(SUM(attributed_token_active_ms)) AS total_duration_ms,
+      COUNT(DISTINCT occurred_day_sp) AS execution_day_count FROM attributed_token_active_facts
+  ), bounds AS (
+    SELECT MIN(day) AS start_day, MAX(day) AS end_day, COUNT(*) AS day_count FROM (
+      SELECT occurred_day_sp AS day FROM activities UNION SELECT occurred_day_sp AS day FROM canonical_work_items
+      UNION SELECT occurred_day_sp AS day FROM canonical_artifacts)
+  ), canonical_items AS MATERIALIZED (
+    SELECT json_extract(payload_json, '$.entity_kind') AS entity_kind,
+      json_extract(payload_json, '$.id') AS id, json_extract(payload_json, '$.status') AS status,
+      json_extract(payload_json, '$.risk') AS risk, json_extract(payload_json, '$.occurred_at') AS occurred_at
+    FROM zaip_aios_activities WHERE payload_type='work_item'
+  ), items AS MATERIALIZED (
+    SELECT entity_kind, id, status, risk, occurred_at FROM canonical_items
+    UNION ALL SELECT 'task', a.task_id, MAX(a.work_item_status), MAX(a.risk), MIN(a.occurred_at)
+      FROM zaip_aios_activities a WHERE a.payload_type IS NULL AND a.task_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM canonical_items c WHERE c.entity_kind='task' AND c.id=a.task_id) GROUP BY task_id
+    UNION ALL SELECT 'spec', a.spec_id, MAX(a.work_item_status), MAX(a.risk), MIN(a.occurred_at)
+      FROM zaip_aios_activities a WHERE a.payload_type IS NULL AND a.spec_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM canonical_items c WHERE c.entity_kind='spec' AND c.id=a.spec_id) GROUP BY spec_id
+    UNION ALL SELECT 'prd', a.prd_id, MAX(a.work_item_status), MAX(a.risk), MIN(a.occurred_at)
+      FROM zaip_aios_activities a WHERE a.payload_type IS NULL AND a.prd_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM canonical_items c WHERE c.entity_kind='prd' AND c.id=a.prd_id) GROUP BY prd_id
+  ), item_totals AS (
+    SELECT SUM(entity_kind='task') AS task_count,
+      SUM(entity_kind='task' AND status='completed') AS completed_task_count,
+      MAX(CASE WHEN entity_kind='task' THEN occurred_at END) AS latest_task_created_at,
+      SUM(entity_kind='spec') AS spec_count, SUM(entity_kind='spec' AND status IN ('completed','delivered')) AS completed_spec_count,
+      SUM(entity_kind='prd') AS prd_count, SUM(entity_kind='prd' AND status IN ('completed','delivered')) AS completed_prd_count FROM items
+  ), task_status AS (
+    SELECT json_group_object(status, task_count) AS task_status_json FROM (
+      SELECT COALESCE(status, 'draft') AS status, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(status, 'draft'))
+  ), task_risk AS (
+    SELECT json_group_object(risk, task_count) AS task_risk_json FROM (
+      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(risk, 'standard'))
+  )
+  SELECT totals.*, run_totals.*, duration_totals.*, bounds.*, item_totals.*, task_status.*, task_risk.*
+    FROM totals CROSS JOIN run_totals CROSS JOIN duration_totals CROSS JOIN bounds
+    CROSS JOIN item_totals CROSS JOIN task_status CROSS JOIN task_risk`)
+    .get() as Record<string, unknown>;
+  if (process.env.ZAIP_DASHBOARD_PROFILE_FIRST_FOLD === "1") {
+    timings.viewport_overview = Math.round((performance.now() - startedAt) * 10) / 10;
+    console.info(
+      JSON.stringify({
+        event: "dashboard_first_fold_select",
+        select: "viewport_overview",
+        elapsed_ms: timings.viewport_overview,
+      }),
+    );
+  }
+  return {
+    aggregate: {
+      days: number(row.day_count),
+      start_day: typeof row.start_day === "string" ? row.start_day : null,
+      end_day: typeof row.end_day === "string" ? row.end_day : null,
+      task_count: number(row.task_count),
+      completed_task_count: number(row.completed_task_count),
+      spec_count: number(row.spec_count),
+      completed_spec_count: number(row.completed_spec_count),
+      prd_count: number(row.prd_count),
+      completed_prd_count: number(row.completed_prd_count),
+      total_run_count: number(row.total_run_count),
+      agent_invocation_count: number(row.agent_invocation_count),
+      llm_call_count: nullableNumber(row.llm_call_count),
+      duration_ms: nullableNumber(row.total_duration_ms),
+      total_tokens: nullableNumber(row.total_tokens),
+      total_cost_usd: nullableNumber(row.total_cost_usd),
+      cost_brl: nullableNumber(row.total_cost_brl),
+      execution_day_count: number(row.execution_day_count),
+      latest_task_created_at:
+        typeof row.latest_task_created_at === "string" ? row.latest_task_created_at : null,
+    },
+    task_status_counts:
+      typeof row.task_status_json === "string" ? JSON.parse(row.task_status_json) : {},
+    task_risk_counts: typeof row.task_risk_json === "string" ? JSON.parse(row.task_risk_json) : {},
+  };
+}
+
+export function readFirstFoldBoardAllTime(
+  database: DatabaseSync,
+  fallback: () => SqliteFirstFoldAllTimeBoard,
+): SqliteFirstFoldAllTimeBoard {
+  return (
+    persisted<SqliteFirstFoldAllTimeBoard>(database, "first_fold_all_time_board_cache") ??
+    fallback()
+  );
+}
+
+export function readFirstFoldTopTasksAllTime(
+  database: DatabaseSync,
+): SqliteFirstFoldAllTime["top_tasks"] {
+  return database
+    .prepare("SELECT * FROM zaip_vw_first_fold_top_tasks_all_time ORDER BY rank")
+    .all() as SqliteFirstFoldAllTime["top_tasks"];
+}
+
+export function readFirstFoldMonthlyQuick(
+  database: DatabaseSync,
+  existing: SqliteFirstFoldMonthlyQuick | null | undefined,
+  filter: { from: string | null; to: string | null },
+): { cache: SqliteFirstFoldMonthlyQuick | null; result: SqliteFirstFoldMonthlyQuick | null } {
+  let cache = existing;
+  if (cache === undefined) {
+    const candidate = persisted<Partial<SqliteFirstFoldMonthlyQuick>>(
+      database,
+      "first_fold_monthly_quick_cache",
+    );
+    cache =
+      candidate !== null &&
+      typeof candidate.from_day === "string" &&
+      typeof candidate.to_day === "string" &&
+      candidate.aggregate !== undefined &&
+      candidate.pages !== undefined &&
+      Array.isArray(candidate.top_tasks)
+        ? (candidate as SqliteFirstFoldMonthlyQuick)
+        : null;
+  }
+  if (cache === null) return { cache, result: null };
+  const from = filter.from?.slice(0, 10) ?? null;
+  const to = filter.to?.slice(0, 10) ?? null;
+  const exactRange = from === cache.from_day && to === cache.to_day;
+  const sameMonthLaterDay =
+    from === cache.from_day &&
+    to !== null &&
+    to > cache.to_day &&
+    to.slice(0, 7) === cache.from_day.slice(0, 7);
+  const noUncoveredFacts =
+    cache.source_latest_day === null || cache.source_latest_day <= cache.to_day;
+  if (exactRange || (sameMonthLaterDay && noUncoveredFacts)) return { cache, result: cache };
+  const latestMonth =
+    cache.source_latest_day === null
+      ? cache.from_day.slice(0, 7)
+      : cache.source_latest_day.slice(0, 7);
+  if (from === null || to === null || from.slice(0, 7) <= latestMonth)
+    return { cache, result: null };
+  return {
+    cache,
+    result: {
+      from_day: from,
+      to_day: to,
+      source_latest_day: cache.source_latest_day,
+      aggregate: {
+        days: 0,
+        total_run_count: 0,
+        agent_invocation_count: 0,
+        llm_call_count: null,
+        duration_ms: null,
+        total_tokens: null,
+        cost_brl: null,
+        execution_day_count: 0,
+      },
+      pages: { task: [], spec: [], prd: [] },
+      top_tasks: [],
+    },
+  };
+}

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

@@ -0,0 +1,121 @@
+import { randomUUID } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+
+const technicalPayloads = [
+  ["first_fold_viewport_cache", "first_fold_viewport_cache:all_time"],
+  ["first_fold_all_time_cache", "first_fold_all_time_cache:all_time"],
+  ["first_fold_all_time_board_cache", "first_fold_all_time_board_cache:all_time"],
+  ["cost_monitor_summary_cache", "cost_monitor_summary_cache:all_time"],
+  ["cost_monitor_summary_month_cache", "cost_monitor_summary_month_cache:current"],
+  ["first_fold_monthly_quick_cache", "first_fold_monthly_quick_cache:default"],
+] as const;
+
+export type FirstFoldPayloads = Record<(typeof technicalPayloads)[number][0], string>;
+
+type BoardPayload = { pages?: Record<string, unknown>; from_day?: unknown; to_day?: unknown };
+
+function readPayload(database: DatabaseSync, payloadType: string): BoardPayload | null {
+  const row = database
+    .prepare(
+      "SELECT payload_json FROM zaip_aios_activities WHERE payload_type=? ORDER BY recorded_at DESC LIMIT 1",
+    )
+    .get(payloadType) as { payload_json?: string } | undefined;
+  if (typeof row?.payload_json !== "string") return null;
+  try {
+    const payload = JSON.parse(row.payload_json) as unknown;
+    return payload !== null && typeof payload === "object" ? (payload as BoardPayload) : null;
+  } catch {
+    return null;
+  }
+}
+
+function exactWorkPageCounts(database: DatabaseSync, from?: string, to?: string) {
+  // Technical payload rows are recorded when the snapshot is built, so the
+  // table-level occurred_day_sp describes the rebuild day. Monthly eligibility
+  // must use the canonical work item's own day persisted inside payload_json;
+  // otherwise every historical item appears to belong to the rebuild month and
+  // a complete immutable seed is rejected on every launcher start.
+  const canonicalDay = "json_extract(payload_json, '$.occurred_day_sp')";
+  const where = from && to ? ` AND ${canonicalDay} >= ? AND ${canonicalDay} <= ?` : "";
+  const rows = database
+    .prepare(
+      `SELECT json_extract(payload_json, '$.entity_kind') AS kind, COUNT(*) AS count
+       FROM zaip_aios_activities WHERE payload_type='work_item'${where} GROUP BY kind`,
+    )
+    .all(...(from && to ? [from, to] : [])) as Array<{ kind: string; count: number }>;
+  return Object.fromEntries(rows.map((row) => [row.kind, Number(row.count)]));
+}
+
+function matchesWorkPopulation(
+  database: DatabaseSync,
+  payload: BoardPayload,
+  monthly = false,
+): boolean {
+  const from = typeof payload.from_day === "string" ? payload.from_day : undefined;
+  const to = typeof payload.to_day === "string" ? payload.to_day : undefined;
+  if (monthly && (!from || !to)) return false;
+  const expected = exactWorkPageCounts(
+    database,
+    monthly ? from : undefined,
+    monthly ? to : undefined,
+  );
+  return ["task", "spec", "prd"].every(
+    (kind) =>
+      Array.isArray(payload.pages?.[kind]) &&
+      payload.pages?.[kind].length === (expected[kind] ?? 0),
+  );
+}
+
+/** A seed is eligible only after every first-fold payload has been committed. */
+export function hasRequiredFirstFoldPayloads(database: DatabaseSync): boolean {
+  const count = Number(
+    (
+      database
+        .prepare(
+          `SELECT COUNT(DISTINCT payload_type) AS count FROM zaip_aios_activities
+           WHERE payload_type IN (${technicalPayloads.map(() => "?").join(", ")})`,
+        )
+        .get(...technicalPayloads.map(([payloadType]) => payloadType)) as { count?: number }
+    ).count ?? 0,
+  );
+  if (count !== technicalPayloads.length) return false;
+  const allTime = readPayload(database, "first_fold_all_time_board_cache");
+  const monthly = readPayload(database, "first_fold_monthly_quick_cache");
+  return (
+    allTime !== null &&
+    monthly !== null &&
+    matchesWorkPopulation(database, allTime) &&
+    matchesWorkPopulation(database, monthly, true)
+  );
+}
+
+export function persistFirstFoldPayloads(
+  paths: readonly string[],
+  payloads: FirstFoldPayloads,
+): void {
+  for (const path of paths) {
+    const database = new DatabaseSync(path);
+    try {
+      const insert = database.prepare(`INSERT INTO zaip_aios_activities(
+        activity_row_id, activity_source_kind, activity_key, source_path, source_hash,
+        recorded_at, run_role, root_run_id, payload_type, payload_json
+      ) VALUES (?, 'technical_payload', ?, ?, '', datetime('now'), 'technical', 'technical', ?, ?)`);
+      database.exec("BEGIN;");
+      for (const [payloadType, key] of technicalPayloads) {
+        insert.run(
+          `TECH-${randomUUID().toLowerCase()}`,
+          key,
+          `sqlite://${payloadType}/${key.split(":")[1]}`,
+          payloadType,
+          payloads[payloadType],
+        );
+      }
+      database.exec("COMMIT;");
+    } catch (error) {
+      database.exec("ROLLBACK;");
+      throw error;
+    } finally {
+      database.close();
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+export function measureFirstFold<T>(
+  enabled: boolean,
+  report: (phase: string, percent: number, detail: string) => void,
+  phase: string,
+  action: () => T,
+): T {
+  const startedAt = performance.now();
+  const result = action();
+  if (enabled) {
+    const elapsedMs = Math.round(performance.now() - startedAt);
+    report(phase, 82, `${phase}: ${elapsedMs}ms.`);
+    process.stderr.write(
+      `${JSON.stringify({ event: "dashboard_sqlite_first_fold", phase, elapsed_ms: elapsedMs })}\n`,
+    );
+  }
+  return result;
+}
+
+export function measureFirstFoldQuery<T>(phase: string, action: () => T): T {
+  const startedAt = performance.now();
+  const result = action();
+  if (process.env.ZAIP_DASHBOARD_LAUNCH_PROGRESS === "1")
+    process.stderr.write(
+      `${JSON.stringify({ event: "dashboard_sqlite_first_fold_query", phase, elapsed_ms: Math.round(performance.now() - startedAt) })}\n`,
+    );
+  return result;
+}

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

@@ -110,7 +110,14 @@ export const SQLITE_VIEW_CONTRACTS = [
   ],
   ["cost_monitor_zaip_agents", "cost-monitor", canonicalRunMetrics, "agent totals", "offset", xlsx],
   ["cost_monitor_models", "cost-monitor", canonicalRunMetrics, "model totals", "offset", xlsx],
-  ["cost_monitor_providers", "cost-monitor", canonicalRunMetrics, "provider totals", "offset", xlsx],
+  [
+    "cost_monitor_providers",
+    "cost-monitor",
+    canonicalRunMetrics,
+    "provider totals",
+    "offset",
+    xlsx,
+  ],
   ["cost_monitor_tasks", "cost-monitor", canonicalRunMetrics, "task totals", "offset", xlsx],
   ["cost_monitor_specs", "cost-monitor", canonicalRunMetrics, "SPEC totals", "offset", xlsx],
   ["cost_monitor_prds", "cost-monitor", canonicalRunMetrics, "PRD totals", "offset", xlsx],
@@ -171,7 +178,14 @@ export const SQLITE_VIEW_CONTRACTS = [
     "offset",
     xlsx,
   ],
-  ["operations_daily", "operations", canonicalRunMetrics, "daily operations totals", "offset", xlsx],
+  [
+    "operations_daily",
+    "operations",
+    canonicalRunMetrics,
+    "daily operations totals",
+    "offset",
+    xlsx,
+  ],
   [
     "operations_monthly",
     "operations",

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

@@ -0,0 +1,15 @@
+import type { DatabaseSync } from "node:sqlite";
+
+/** Persists the exact canonical Board summary so runtime pages never re-expand its lineage CTE. */
+export function materializeOperationsWorkProjection(database: DatabaseSync): void {
+  database.exec(`
+    CREATE TABLE operations_work_projection AS
+    SELECT summary.*, canonical.stage, canonical.spec_id,
+      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)) AS change_id,
+      (SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) AS origin,
+      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE((SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
+    FROM zaip_vw_operations_work_kanban summary
+    JOIN canonical_work_items canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id;
+    CREATE INDEX operations_work_projection_order ON operations_work_projection(occurred_at DESC, id DESC);
+  `);
+}