@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -1,49 +1,126 @@
-import { execFile } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { loadWorkspaceLayout, WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
 import { fxRateSchema, PricingRepository, pricingCatalogSchema } from "@zaip-ai/costs";
-import { buildCostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/server";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "@zaip-ai/dashboard-cost-monitor/server";
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
 import {
   buildOperationsProjection,
-  projectExecutionDurations,
+  buildQuickOperationsProjection,
   readPrdDetail,
   readSpecDetail,
   readTaskDetail,
-  recalculateOperationsRunSummary,
 } from "@zaip-ai/dashboard-operations/server";
-import { buildTaskTrace } from "@zaip-ai/dashboard-traceability/server";
+import {
+  buildTaskTrace,
+  buildTraceStageRecords,
+  classifyTraceDocument,
+  timestampsFromContent,
+} from "@zaip-ai/dashboard-traceability/server";
+import { type CompactRunMetric, 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,
   AgentCatalogUpdateError,
   persistAgentCatalogUpdate,
   readAgentCatalogSettings,
 } from "./agent-catalog-settings.js";
-import { mergeManifestRuns } from "./manifest-runs.js";
-import { persistProjectSettings, readProjectSettings } from "./project-settings.js";
 import {
-  configuredAgentNames,
-  invocationSummariesForPeriod,
-  queryValues,
-  selectedCurrency,
-} from "./server-summary-helpers.js";
+  persistProjectSettings,
+  readProjectOverview,
+  readProjectSettings,
+} from "./project-settings.js";
+import {
+  type BoardClassification,
+  boardFilters,
+  boardPage,
+  boardStage,
+  classificationPage,
+} from "./server-board.js";
+import { registerDailyReadModelRoute } from "./server-daily-read-models-route.js";
+import {
+  changeEntityPageRows,
+  decisionEntityPageRows,
+  filterLifecyclePageRows,
+  operationsPageFilters,
+} from "./server-operations-pages.js";
+import { registerOperationsRunsRoute } from "./server-operations-runs-route.js";
+import { projectionPeriodFilter } from "./server-period.js";
+import {
+  buildCanonicalOperationsProjection,
+  buildCurrentCostProjection,
+  buildManifestCostRunPage,
+  buildManifestFirstCostProjection,
+  filterCostRunRows,
+  isUnfilteredCostRequest,
+  knownWorkIds,
+  normalizeWorkPriority,
+  pageCostRunRows,
+  readCurrentFxRate,
+  readWorkPriority,
+} from "./server-projections.js";
+import { queryValues, selectedCurrency } from "./server-summary-helpers.js";
+import { dashboardIdentity, dashboardWorkspaceKey, reconcileOpenWork } from "./server-workspace.js";
+import {
+  rebuildSqliteReadModel,
+  SqliteReadModelFileSystem,
+  sqliteViewMetadata,
+} from "./sqlite-read-model.js";
 
 export { manifestRun, mergeManifestRuns } from "./manifest-runs.js";
+export { projectionPeriodFilter } from "./server-period.js";
+export {
+  dashboardWorkspaceKey,
+  githubRepositoryFromRemote,
+  type ReconciliationItem,
+  type ReconciliationResult,
+  reconciliationResult,
+} from "./server-workspace.js";
+export {
+  rebuildSqliteReadModel,
+  SqliteReadModelFileSystem,
+  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,
+  }));
+}
 
 const API_PREFIX = "/api/v2";
 const HOST = "127.0.0.1";
-const RUNTIME_KIND = "zaip-dashboard-local-runtime";
-const SESSION_COOKIE = "zaip-dashboard-session";
-const DASHBOARD_CONFIG_PATH = ".agents/dashboard/dashboard.config.json";
-const execFileAsync = promisify(execFile);
+const RUNTIME_KIND = "zaip-dashboard-sqlite-runtime";
+const SESSION_COOKIE = "zaip-dashboard-sqlite-session";
+const WORK_PRIORITY_PATH = ".agents/dashboard/work-priority.json";
+const SNAPSHOT_CACHE_TTL_MS = 5_000;
 const agentPortraitFiles: Record<string, string> = {
   "agent-orchestrator": "1 - Dave - Product Owner.png",
   "agent-builder": "2 - Rafa - Tech Lead.png",
@@ -87,6 +164,13 @@ export function openWorkIds(items: readonly ActiveWorkItem[]): string[] {
 
 interface DashboardAppOptions {
   syncAgentAdapters?: () => Promise<AgentAdapterSyncResult>;
+  filesystem?: WorkspaceFileSystem;
+  canonicalFilesystem?: WorkspaceFileSystem;
+  /** Test seam for the disposable SQLite serving mode. */
+  snapshotReadOnly?: boolean;
+  reconcileOpenWork?: typeof reconcileOpenWork;
+  refreshReadModel?: () => Promise<void>;
+  snapshotState?: "current" | "updating";
 }
 
 class V2WorkspaceRequiredError extends Error {
@@ -126,164 +210,520 @@ function shouldBootstrapBrowserSession(context: Context): boolean {
   return context.req.header("sec-fetch-site") !== "cross-site";
 }
 
-async function dashboardIdentity(
+async function requireV2Layout(filesystem: WorkspaceFileSystem): Promise<WorkspaceLayout> {
+  const layout = await loadWorkspaceLayout(filesystem);
+  if (layout.version === 1) {
+    throw new V2WorkspaceRequiredError("Dashboard API requires a modern ZAIP-AIOS workspace");
+  }
+  return layout;
+}
+
+function headOrJson(
+  context: Context,
+  payload: unknown,
+  status: ContentfulStatusCode = 200,
+  cacheable = false,
+): Response {
+  if (cacheable) {
+    const etag = `"${createHash("sha256").update(JSON.stringify(payload)).digest("base64url")}"`;
+    context.header("ETag", etag);
+    context.header("Cache-Control", "private, no-cache");
+    if (context.req.header("if-none-match") === etag) return context.body(null, 304);
+  }
+  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.
+ * Duration intentionally retains the shared hybrid legacy policy in the
+ * Operations module; its underlying daily rows are still SQLite-backed.
+ */
+async function buildFirstFoldQuickProjection(
   filesystem: WorkspaceFileSystem,
-  workspaceRoot: string,
-): Promise<{ title: string; repository_name: string }> {
-  let title = process.env.ZAIP_DASHBOARD_TITLE?.trim() || "Dashboard Zaip AIOS";
-  let repositorySetting = "auto";
-  try {
-    if (await filesystem.exists(DASHBOARD_CONFIG_PATH)) {
-      const config = JSON.parse(await filesystem.readText(DASHBOARD_CONFIG_PATH)) as {
-        github_repository?: unknown;
-        title?: unknown;
-      };
-      if (typeof config.title === "string" && config.title.trim()) title = config.title.trim();
-      if (typeof config.github_repository === "string") {
-        repositorySetting = config.github_repository.trim();
-      }
+  layout: WorkspaceLayout,
+  filter: { from: string | null; to: string | null },
+  options: {
+    includeBoardTasks?: boolean;
+    includeExtended?: boolean;
+    includePeriods?: boolean;
+    includeTopTasks?: boolean;
+  } = {},
+): Promise<OperationsProjection> {
+  // The comparison runtime deliberately has no lifecycle daily aggregates in
+  // its snapshot.  Its immutable filesystem contains only canonical records,
+  // while the SQL views supply the first-fold facts.  Never enter the legacy
+  // quick projection here: it requires lifecycle daily read models and would
+  // make an otherwise valid SQLite dashboard fail on first paint.
+  const projection =
+    filesystem instanceof SqliteReadModelFileSystem
+      ? buildSqliteOperationsProjection(filesystem, layout, filter, options)
+      : await buildQuickOperationsProjection(filesystem, layout, filter, options);
+  if (!(filesystem instanceof SqliteReadModelFileSystem)) return projection;
+  const cachedMonthlyQuick = filesystem.firstFoldMonthlyQuick(filter);
+  const aggregate =
+    filter.from === null && filter.to === null
+      ? filesystem.firstFoldViewportAllTime().aggregate
+      : (cachedMonthlyQuick?.aggregate ?? filesystem.firstFoldAggregate(filter));
+  return {
+    ...projection,
+    summary: {
+      ...projection.summary,
+      run_count: aggregate.total_run_count,
+      overview_metrics: {
+        ...projection.summary.overview_metrics,
+        duration_ms: aggregate.duration_ms,
+        tokens: aggregate.total_tokens,
+        cost_brl: aggregate.cost_brl,
+        execution_day_count: aggregate.execution_day_count,
+        data_source: "run_records",
+      },
+    },
+  };
+}
+
+/**
+ * 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.
+ */
+function buildSqliteOperationsProjection(
+  filesystem: SqliteReadModelFileSystem,
+  layout: WorkspaceLayout,
+  filter: { from: string | null; to: string | null },
+  options: {
+    includeBoardTasks?: boolean;
+    includeExtended?: boolean;
+    includePeriods?: boolean;
+    includeTopTasks?: boolean;
+  },
+): OperationsProjection {
+  const cachedMonthlyQuick = filesystem.firstFoldMonthlyQuick(filter);
+  const fullAllTime =
+    filter.from === null && filter.to === null
+      ? options.includeExtended === true
+        ? filesystem.firstFoldAllTime()
+        : null
+      : null;
+  const allTime =
+    fullAllTime ??
+    (filter.from === null && filter.to === null ? filesystem.firstFoldViewportAllTime() : null);
+  const page = <T extends "task" | "spec" | "prd">(kind: T) =>
+    cachedMonthlyQuick?.pages[kind] ?? filesystem.summaryPage(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 allTimeTopTasks =
+    filter.from === null &&
+    filter.to === null &&
+    (fullAllTime !== null || options.includeTopTasks === true)
+      ? (fullAllTime?.top_tasks ?? filesystem.firstFoldTopTasksAllTime())
+      : null;
+  const topTasks =
+    allTimeTopTasks === null
+      ? (cachedMonthlyQuick?.top_tasks ?? filesystem.topTasks(filter)).map((task) => ({
+          task_id: task.task_id,
+          duration_ms: task.duration_ms,
+          total_tokens: task.total_tokens,
+          cost_brl: task.cost_brl,
+          run_count: task.run_count,
+        }))
+      : projectAllTimeTopTasks(allTimeTopTasks);
+  const macroMetrics =
+    fullAllTime === null
+      ? undefined
+      : (Object.fromEntries(
+          (["specs", "prds"] as const).map((kind) => {
+            const metric = fullAllTime.macro_metrics[kind];
+            return [
+              kind,
+              {
+                status_counts: metric.status_counts,
+                classification_counts: metric.classification_counts,
+                entity_count: metric.entity_count,
+                total_run_count: metric.total_run_count,
+                total_duration_ms: metric.total_duration_ms,
+                total_tokens: metric.total_tokens,
+                total_cost_usd: metric.total_cost_usd,
+                total_cost_brl: metric.total_cost_brl,
+                average_duration_ms: metric.average_duration_ms,
+                average_tokens: metric.average_tokens,
+                average_cost_usd: metric.average_cost_usd,
+                average_cost_brl: metric.average_cost_brl,
+                latest_created_at: metric.latest_created_at,
+                top_entities: metric.top_entities.map((entity) => ({
+                  entity_id: entity.entity_id,
+                  title: entity.title,
+                  duration_ms: entity.total_duration_ms,
+                  total_tokens: entity.total_tokens,
+                  total_cost_usd: entity.total_cost_usd,
+                  cost_brl: entity.total_cost_brl,
+                  run_count: entity.total_run_count,
+                  duration_share: entity.duration_share,
+                })),
+              },
+            ];
+          }),
+        ) as NonNullable<
+          NonNullable<OperationsProjection["summary"]["overview_metrics"]>["macro_metrics"]
+        >);
+  const statuses: Record<string, number> = allTime?.task_status_counts ?? {};
+  const risks: Record<string, number> = allTime?.task_risk_counts ?? {};
+  if (allTime === null) {
+    for (const task of tasks) {
+      const status = typeof task.status === "string" ? task.status : "draft";
+      const risk = typeof task.risk === "string" ? task.risk : "standard";
+      statuses[status] = (statuses[status] ?? 0) + 1;
+      risks[risk] = (risks[risk] ?? 0) + 1;
     }
-  } catch {
-    // A configuração visual nunca deve impedir a inicialização do dashboard.
   }
-  if (repositorySetting.toLowerCase() !== "auto") {
+  const latest =
+    allTime?.aggregate.latest_task_created_at ??
+    [...tasks, ...specs, ...prds]
+      .map((row) => (typeof row.occurred_at === "string" ? row.occurred_at : null))
+      .filter((value): value is string => value !== null)
+      .sort()
+      .at(-1) ??
+    null;
+  const unavailableUsage = {
+    events: 0,
+    tokens: { input: null, cached_input: null, output: null, reasoning: null, total: null },
+    cost: { usd: null, brl: null },
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+  };
+  const totalUsage = {
+    ...unavailableUsage,
+    tokens: { ...unavailableUsage.tokens, total: aggregate.total_tokens },
+    cost: { ...unavailableUsage.cost, brl: aggregate.cost_brl },
+  };
+  const usage = {
+    conversation: unavailableUsage,
+    planning: unavailableUsage,
+    execution: unavailableUsage,
+    total: totalUsage,
+    new_work: unavailableUsage,
+    rework: unavailableUsage,
+  };
+  const dailyPeriods = options.includePeriods === true ? filesystem.dailyPeriods(filter) : {};
+  const hasUnknownUsage = Object.values(dailyPeriods).some(
+    (period) => period.usage.total_tokens.unknown > 0 || period.usage.cost.unknown > 0,
+  );
+  const taskProjection = (row: Record<string, unknown>) => ({
+    schema_version: 2 as const,
+    id: String(row.id),
+    revision: 1,
+    change_id: "",
+    title: String(row.title ?? row.id),
+    short_name: String(row.title ?? row.id),
+    objective: "",
+    status: normalizeTaskStatus(row.status),
+    attempt_count: null,
+    risk: normalizeRisk(row.risk),
+    priority: "medium" as const,
+    owner: null,
+    requirement_ids: [],
+    acceptance_ids: [],
+    depends_on: [],
+    write_scopes: [],
+    created_at: String(row.occurred_at),
+    updated_at: String(row.occurred_at),
+    started_at: null,
+    finished_at: null,
+    result: null,
+    artifact_path: ".agents/records",
+    progress: 0,
+    spec_id: null,
+    execution_started: false,
+    telemetry: {
+      duration_ms: nullableMetric(row.total_duration),
+      tokens: nullableMetric(row.total_tokens),
+      cost_brl: nullableMetric(row.total_cost_brl),
+    },
+  });
+  const macroProjection = (row: Record<string, unknown>, kind: "prd" | "spec") => {
+    const entityUsage = {
+      ...unavailableUsage,
+      tokens: { ...unavailableUsage.tokens, total: nullableMetric(row.total_tokens) },
+      cost: { ...unavailableUsage.cost, brl: nullableMetric(row.total_cost_brl) },
+    };
     return {
-      title,
-      repository_name: githubRepositoryFromRemote(repositorySetting) ?? "",
+      id: String(row.id),
+      title: String(row.title ?? row.id),
+      created_at: String(row.occurred_at),
+      updated_at: String(row.occurred_at),
+      kind,
+      parent_id: null,
+      artifact_path: ".agents/records",
+      lifecycle_status: String(row.status ?? "draft"),
+      work_status: normalizeMacroStatus(row.status),
+      execution_ids: [],
+      task_ids: [],
+      planned_tasks: [],
+      canonical_run_ids: [],
+      run_ids: [],
+      root_execution_run_ids: [],
+      execution_count: 0,
+      task_count: 0,
+      run_count: nullableMetric(row.invocation_count) ?? 0,
+      duration_ms: nullableMetric(row.total_duration),
+      decisions: { human: 0, agent: 0 },
+      rework_run_count: 0,
+      quality: {
+        completed_tasks: 0,
+        task_completion_rate: 0,
+        terminal_runs: 0,
+        successful_runs: 0,
+        terminal_success_rate: 0,
+        rework_rate: 0,
+      },
+      usage: {
+        conversation: unavailableUsage,
+        planning: unavailableUsage,
+        execution: unavailableUsage,
+        total: entityUsage,
+        new_work: unavailableUsage,
+        rework: unavailableUsage,
+      },
     };
-  }
-  try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["-C", workspaceRoot, "remote", "get-url", "origin"],
-      { encoding: "utf8", windowsHide: true },
-    );
-    return { title, repository_name: githubRepositoryFromRemote(stdout) ?? "" };
-  } catch {
-    // Falha de detecção mantém o badge ausente sem impedir o dashboard.
-  }
-  return { title, repository_name: "" };
+  };
+  return {
+    schema_version: 2,
+    layout_version: layout.version as 2 | 3,
+    readonly: true,
+    source: ".agents/records",
+    filters: filter,
+    summary: {
+      prd_count: allTime?.aggregate.prd_count ?? prds.length,
+      spec_count: allTime?.aggregate.spec_count ?? specs.length,
+      execution_count: 0,
+      task_count: taskCount,
+      run_count: aggregate.total_run_count,
+      overview_metrics: {
+        duration_ms: aggregate.duration_ms,
+        execution_day_count: aggregate.execution_day_count,
+        tokens: aggregate.total_tokens,
+        cost_brl: aggregate.cost_brl,
+        prd_count: allTime?.aggregate.prd_count ?? prds.length,
+        spec_count: allTime?.aggregate.spec_count ?? specs.length,
+        selected_counts: {
+          prds: allTime?.aggregate.prd_count ?? prds.length,
+          specs: allTime?.aggregate.spec_count ?? specs.length,
+        },
+        task_count: taskCount,
+        completed_prd_count:
+          allTime?.aggregate.completed_prd_count ??
+          prds.filter((row) => row.status === "completed").length,
+        completed_spec_count:
+          allTime?.aggregate.completed_spec_count ??
+          specs.filter((row) => row.status === "completed").length,
+        completed_task_count: allTime?.aggregate.completed_task_count ?? statuses.completed ?? 0,
+        task_status_counts: statuses,
+        task_risk_counts: risks,
+        top_tasks: topTasks,
+        ...(macroMetrics === undefined ? {} : { macro_metrics: macroMetrics }),
+        latest_task_created_at: latest,
+        coverage: { duration: 1, tokens: hasUnknownUsage ? 0 : 1, cost: hasUnknownUsage ? 0 : 1 },
+        data_source: "run_records",
+        partial: true,
+      },
+      decisions: { human: 0, agent: 0 },
+      source_latest_at: latest,
+      quality: {
+        completed_tasks: statuses.completed ?? 0,
+        task_completion_rate:
+          taskCount === 0
+            ? 0
+            : (allTime?.aggregate.completed_task_count ?? statuses.completed ?? 0) / taskCount,
+        terminal_runs: 0,
+        successful_runs: 0,
+        terminal_success_rate: 0,
+        rework_rate: 0,
+      },
+      reconciliation: {
+        phase_tokens_match_total: true,
+        phase_usd_match_total: true,
+        phase_brl_match_total: true,
+        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 },
+    prds: prds.map((row) => macroProjection(row, "prd")),
+    specs: specs.map((row) => macroProjection(row, "spec")),
+    tasks: options.includeBoardTasks ? tasks.map(taskProjection) : [],
+    changes: [],
+    executions: [],
+    runs: [],
+    decisions: [],
+    evidences: [],
+    validations: [],
+  };
 }
 
-export function githubRepositoryFromRemote(remote: string): string | null {
-  const trimmed = remote.trim();
-  const match =
-    trimmed.match(/github\.com(?::|\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i) ??
-    trimmed.match(/^([^/:\s]+)\/([^/\s]+?)(?:\.git)?$/);
-  return match ? `${match[1]}/${match[2]}` : null;
+function nullableMetric(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
-export function dashboardWorkspaceKey(workspaceRoot: string): string {
-  return createHash("sha256").update(resolve(workspaceRoot)).digest("hex").slice(0, 16);
+function normalizeTaskStatus(
+  value: unknown,
+):
+  | "draft"
+  | "planned"
+  | "executing"
+  | "verifying"
+  | "completed"
+  | "failed"
+  | "blocked"
+  | "cancelled" {
+  return [
+    "draft",
+    "planned",
+    "executing",
+    "verifying",
+    "completed",
+    "failed",
+    "blocked",
+    "cancelled",
+  ].includes(String(value))
+    ? (String(value) as
+        | "draft"
+        | "planned"
+        | "executing"
+        | "verifying"
+        | "completed"
+        | "failed"
+        | "blocked"
+        | "cancelled")
+    : "draft";
 }
 
-export interface ReconciliationItem {
-  id: string;
-  reason: string | null;
+function normalizeRisk(value: unknown): "lite" | "standard" | "critical" {
+  return ["lite", "standard", "critical"].includes(String(value))
+    ? (String(value) as "lite" | "standard" | "critical")
+    : "standard";
 }
 
-export interface ReconciliationResult {
-  reconciled_ids: string[];
-  blocked: ReconciliationItem[];
-  not_reconciled: ReconciliationItem[];
+function normalizeMacroStatus(
+  value: unknown,
+): "planning" | "executing" | "verifying" | "completed" | "blocked" | "failed" | "cancelled" {
+  const status = String(value);
+  if (["executing", "verifying", "completed", "blocked", "failed", "cancelled"].includes(status))
+    return status as "executing" | "verifying" | "completed" | "blocked" | "failed" | "cancelled";
+  return "planning";
 }
 
-async function reconcileOpenWork(
+async function firstFoldCostSource(
   filesystem: WorkspaceFileSystem,
-  workspaceRoot: string,
-): Promise<ReconciliationResult> {
-  if (!(await filesystem.exists(".agents/runtime/bin/zaip.mjs"))) {
-    return { reconciled_ids: [], blocked: [], not_reconciled: [] };
+  filters: Parameters<SqliteReadModelFileSystem["invocationCostRows"]>[0] = {
+    from: null,
+    to: null,
+  },
+): Promise<CostSummarySource> {
+  if (filesystem instanceof SqliteReadModelFileSystem) {
+    return filesystem.costMonitorSummaryAggregate(filters) as CostSummarySource;
   }
-  const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
-  const { stdout } = await execFileAsync(
-    process.execPath,
-    [cliPath, "run", "reconcile", "--open", "--json"],
-    { cwd: workspaceRoot, windowsHide: true, timeout: 120_000, maxBuffer: 10 * 1_024 * 1_024 },
-  );
-  return reconciliationResult(JSON.parse(stdout) as unknown);
+  const daily = await new LifecycleManifestStore(filesystem).readDailyReadModels("overview");
+  if (daily === null) throw new Error("Lifecycle daily overview is not initialized");
+  return {
+    periods: {
+      daily: Object.fromEntries(
+        Object.entries(daily.days).map(([day, model]) => [day, model.overview]),
+      ),
+    },
+  } satisfies CostSummarySource;
 }
 
-export function reconciliationResult(value: unknown): ReconciliationResult {
-  const reconciled = new Set<string>();
-  const blocked = new Map<string, string | null>();
-  const notReconciled = new Map<string, string | null>();
-  const remember = (target: Map<string, string | null>, id: unknown, reason: unknown): void => {
-    if (typeof id !== "string") return;
-    target.set(id, typeof reason === "string" && reason.trim() ? reason : null);
+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 records =
-    typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
-  const reconciliations = Array.isArray(records.reconciliations) ? records.reconciliations : [];
-  for (const candidate of reconciliations) {
-    if (typeof candidate !== "object" || candidate === null) continue;
-    const item = candidate as Record<string, unknown>;
-    const reason = item.error;
-    const entities = ["tasks", "changes", "executions", "specs", "prds"].flatMap((key) =>
-      Array.isArray(item[key]) ? item[key] : [],
-    );
-    for (const entity of entities) {
-      if (typeof entity !== "object" || entity === null) continue;
-      const record = entity as Record<string, unknown>;
-      if (
-        item.status === "closed" &&
-        record.status === "completed" &&
-        typeof record.id === "string"
-      ) {
-        reconciled.add(record.id);
-      } else if (record.status === "blocked") {
-        remember(blocked, record.id, record.status_reason ?? reason);
-      } else if (item.status === "deferred") {
-        remember(notReconciled, record.id, reason);
-      }
-    }
-  }
-  const orphanedExecutions = Array.isArray(records.orphaned_executions)
-    ? records.orphaned_executions
-    : [];
-  orphanedExecutions.forEach((id) => {
-    remember(blocked, id, "Execution orphaned after the reconciliation grace period.");
-  });
-  const errors = Array.isArray(records.reconciliation_errors) ? records.reconciliation_errors : [];
-  errors.forEach((candidate) => {
-    if (typeof candidate !== "object" || candidate === null) return;
-    const item = candidate as Record<string, unknown>;
-    remember(notReconciled, item.run_id, item.error);
-  });
-  const unresolved = Array.isArray(records.unresolved_running_run_ids)
-    ? records.unresolved_running_run_ids
-    : [];
-  unresolved.forEach((id) => {
-    remember(notReconciled, id, "Invocation is still running.");
-  });
-  const entries = (items: Map<string, string | null>): ReconciliationItem[] =>
-    [...items.entries()]
-      .map(([id, reason]) => ({ id, reason }))
-      .sort((left, right) => left.id.localeCompare(right.id));
+  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 {
-    reconciled_ids: [...reconciled].sort(),
-    blocked: entries(blocked),
-    not_reconciled: entries(notReconciled),
+    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,
+    },
   };
 }
 
-async function requireV2Layout(filesystem: WorkspaceFileSystem): Promise<WorkspaceLayout> {
-  const layout = await loadWorkspaceLayout(filesystem);
-  if (layout.version === 1) {
-    throw new V2WorkspaceRequiredError("Dashboard API requires a modern ZAIP-AIOS workspace");
-  }
-  return layout;
-}
-
-function headOrJson(
-  context: Context,
-  payload: unknown,
-  status: ContentfulStatusCode = 200,
-): Response {
-  if (context.req.method === "HEAD") return context.body(null, status);
-  return context.json(payload, status);
-}
-
 export function createDashboardApp(
   workspaceRoot = process.env.ZAIP_WORKSPACE ?? process.cwd(),
   sessionToken = defaultSessionToken(),
@@ -291,34 +731,111 @@ export function createDashboardApp(
   options: DashboardAppOptions = {},
 ): Hono {
   const app = new Hono();
-  const filesystem = new WorkspaceFileSystem(workspaceRoot);
+  const filesystem = options.filesystem ?? new WorkspaceFileSystem(workspaceRoot);
+  const isSqliteSnapshot = filesystem instanceof SqliteReadModelFileSystem;
+  // A private SQLite generation is immutable for this app instance. Loading
+  // 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 snapshotReadOnly = options.snapshotReadOnly ?? isSqliteSnapshot;
+  const snapshotState = options.snapshotState ?? "current";
+  const canonicalFilesystem = options.canonicalFilesystem ?? new WorkspaceFileSystem(workspaceRoot);
+  const reconcileOpen = options.reconcileOpenWork ?? reconcileOpenWork;
+  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 }),
+      );
+    });
   const workspaceKey = dashboardWorkspaceKey(workspaceRoot);
   const syncAgentAdapters = options.syncAgentAdapters ?? (() => runAgentAdapterSync(workspaceRoot));
   let catalogWriteTail = Promise.resolve();
-  let snapshotInFlight: Promise<Awaited<ReturnType<typeof dashboardSnapshot>>> | null = null;
-  let cachedSnapshot: Awaited<ReturnType<typeof dashboardSnapshot>> | null = null;
-  let cachedSnapshotAt = 0;
-  let cachedSnapshotKey: string | null = null;
-  const readSnapshot = (context: Context) => {
-    const key = `${selectedCurrency(context)}:${context.req.query("from") ?? ""}:${context.req.query("to") ?? ""}`;
+  type DashboardSnapshot = Awaited<ReturnType<typeof dashboardSnapshot>>;
+  const snapshotInFlight = new Map<string, Promise<DashboardSnapshot>>();
+  const cachedSnapshots = new Map<string, { snapshot: DashboardSnapshot; cachedAt: number }>();
+  const aggregatePayloads = new Map<string, { payload: unknown; cachedAt: number }>();
+  const aggregateInFlight = new Map<string, Promise<unknown>>();
+  const readAggregate = async <T>(
+    key: string,
+    build: () => Promise<T>,
+    fresh = false,
+  ): Promise<T> => {
+    const cached = aggregatePayloads.get(key);
+    // Kanban cards are canonical projections. SQLite generations are immutable,
+    // so retain their expensive board projection until an explicit refresh
+    // clears this map rather than expiring it on the short snapshot TTL.
     if (
-      cachedSnapshot !== null &&
-      cachedSnapshotKey === key &&
-      Date.now() - cachedSnapshotAt < 2_000
+      !fresh &&
+      cached !== undefined &&
+      (key.startsWith("operations:board:") || Date.now() - cached.cachedAt < SNAPSHOT_CACHE_TTL_MS)
     )
-      return Promise.resolve(cachedSnapshot);
-    if (snapshotInFlight !== null) return snapshotInFlight;
-    snapshotInFlight = dashboardSnapshot(filesystem, workspaceRoot, context)
+      return cached.payload as T;
+    const pending = aggregateInFlight.get(key);
+    // A bootstrap fresh read must not observe a normal request that began
+    // before reload. Wait for it to settle, then rebuild and replace cache.
+    if (pending !== undefined) {
+      if (!fresh) return pending as Promise<T>;
+      await pending;
+      return readAggregate(key, build, true);
+    }
+    const pendingBuild = build()
+      .then((payload) => {
+        aggregatePayloads.set(key, { payload, cachedAt: Date.now() });
+        return payload;
+      })
+      .finally(() => aggregateInFlight.delete(key));
+    aggregateInFlight.set(key, pendingBuild);
+    return pendingBuild;
+  };
+  const snapshotKey = (context: Context) => {
+    const { from, to } = projectionPeriodFilter(context);
+    return `${selectedCurrency(context)}:${from ?? ""}:${to ?? ""}`;
+  };
+  const clearSnapshotCache = () => {
+    cachedSnapshots.clear();
+    aggregatePayloads.clear();
+    aggregateInFlight.clear();
+  };
+  let projectionRefreshInFlight: Promise<void> | null = null;
+  const rebuildProjection = async () => {
+    if (projectionRefreshInFlight !== null) return projectionRefreshInFlight;
+    projectionRefreshInFlight = refreshReadModel()
+      .then(() => clearSnapshotCache())
+      .finally(() => {
+        projectionRefreshInFlight = null;
+      });
+    return projectionRefreshInFlight;
+  };
+  const readSnapshot = (context: Context) => {
+    const key = snapshotKey(context);
+    const cached = cachedSnapshots.get(key);
+    if (cached !== undefined && Date.now() - cached.cachedAt < SNAPSHOT_CACHE_TTL_MS) {
+      context.header("X-ZAIP-Snapshot-Cache", "hit");
+      return Promise.resolve(cached.snapshot);
+    }
+    const pending = snapshotInFlight.get(key);
+    if (pending !== undefined) {
+      context.header("X-ZAIP-Snapshot-Cache", "inflight");
+      return pending;
+    }
+    context.header("X-ZAIP-Snapshot-Cache", "miss");
+    const inFlight = readLayout()
+      .then((layout) => dashboardSnapshot(filesystem, workspaceRoot, context, layout))
       .then((snapshot) => {
-        cachedSnapshot = snapshot;
-        cachedSnapshotKey = key;
-        cachedSnapshotAt = Date.now();
+        cachedSnapshots.set(key, { snapshot, cachedAt: Date.now() });
         return snapshot;
       })
       .finally(() => {
-        snapshotInFlight = null;
+        snapshotInFlight.delete(key);
       });
-    return snapshotInFlight;
+    snapshotInFlight.set(key, inFlight);
+    return inFlight;
   };
 
   app.use("*", async (context, next) => {
@@ -342,32 +859,44 @@ export function createDashboardApp(
   app.use(`${API_PREFIX}/*`, async (context, next) => {
     const settingsWrite =
       context.req.method === "PUT" &&
-      (context.req.path === `${API_PREFIX}/pricing` ||
-        context.req.path === `${API_PREFIX}/fx-rate` ||
-        context.req.path === `${API_PREFIX}/agent-catalog` ||
-        context.req.path === `${API_PREFIX}/project-settings`);
+      (context.req.path === `${API_PREFIX}/work-priority` ||
+        context.req.path === `${API_PREFIX}/project-settings` ||
+        (!snapshotReadOnly &&
+          (context.req.path === `${API_PREFIX}/pricing` ||
+            context.req.path === `${API_PREFIX}/fx-rate` ||
+            context.req.path === `${API_PREFIX}/agent-catalog`)));
+    // Reconciliation updates canonical lifecycle records through the supported
+    // CLI. It does not mutate the disposable SQLite read model, so it remains
+    // available while the dashboard serves a read-only snapshot.
     const reconcileWrite =
       context.req.method === "POST" && context.req.path === `${API_PREFIX}/reconcile-open-work`;
+    const projectionRefreshWrite =
+      context.req.method === "POST" && context.req.path === `${API_PREFIX}/refresh-projection`;
     if (
       context.req.method !== "GET" &&
       context.req.method !== "HEAD" &&
       !settingsWrite &&
-      !reconcileWrite
+      !reconcileWrite &&
+      !projectionRefreshWrite
     ) {
       context.header(
         "Allow",
         context.req.path === `${API_PREFIX}/pricing` ||
           context.req.path === `${API_PREFIX}/fx-rate` ||
           context.req.path === `${API_PREFIX}/agent-catalog` ||
-          context.req.path === `${API_PREFIX}/project-settings`
+          context.req.path === `${API_PREFIX}/project-settings` ||
+          context.req.path === `${API_PREFIX}/work-priority`
           ? "GET, HEAD, PUT"
           : context.req.path === `${API_PREFIX}/reconcile-open-work`
             ? "POST"
-            : "GET, HEAD",
+            : context.req.path === `${API_PREFIX}/refresh-projection`
+              ? "POST"
+              : "GET, HEAD",
       );
       return context.json({ error: "Dashboard API is read-only" }, 405);
     }
-    if (context.req.path === `${API_PREFIX}/health`) return next();
+    if (context.req.path === `${API_PREFIX}/health` || context.req.path === `${API_PREFIX}/ready`)
+      return next();
 
     const origin = context.req.header("origin");
     if (origin !== undefined && !isAllowedOrigin(origin)) {
@@ -392,7 +921,7 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/health`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const layout = await readLayout();
       return headOrJson(context, {
         kind: RUNTIME_KIND,
         workspaceKey,
@@ -401,6 +930,8 @@ export function createDashboardApp(
         api_version: 2,
         workspace_layout: layout.version,
         read_only: true,
+        storage: isSqliteSnapshot ? filesystem.metadata() : { storage_mode: "filesystem" },
+        snapshot_state: snapshotState,
       });
     } catch (error) {
       return headOrJson(
@@ -419,17 +950,184 @@ export function createDashboardApp(
     }
   });
 
+  // Launcher readiness proves a canonical projection can be read; health alone
+  // intentionally remains a lightweight process/layout probe.
+  app.on(["GET", "HEAD"], `${API_PREFIX}/ready`, async (context) => {
+    try {
+      const layout = await readLayout();
+      if (isSqliteSnapshot) {
+        const metadata = filesystem.metadata();
+        return headOrJson(context, {
+          kind: RUNTIME_KIND,
+          workspaceKey,
+          status: "ready",
+          workspace_layout: layout.version,
+          storage_mode: metadata.storage_mode,
+          activity_count: metadata.activity_count,
+          // Readiness is only an immutable-generation probe. The default
+          // monthly Operations projection was materialized during rebuild;
+          // /ready must never start a competing projection in the background.
+          day_count: metadata.daily_aggregate_count,
+          snapshot_state: snapshotState,
+        });
+      }
+      const projection = await buildFirstFoldQuickProjection(filesystem, layout, {
+        from: null,
+        to: null,
+      });
+      return headOrJson(context, {
+        kind: RUNTIME_KIND,
+        workspaceKey,
+        status: "ready",
+        source_latest_at: projection.summary.source_latest_at,
+      });
+    } catch (error) {
+      return headOrJson(
+        context,
+        {
+          kind: RUNTIME_KIND,
+          workspaceKey,
+          status: "unavailable",
+          error: error instanceof Error ? error.message : String(error),
+        },
+        503,
+      );
+    }
+  });
+
   app.on(["GET", "HEAD"], `${API_PREFIX}/operations`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const requestStartedAt = performance.now();
+      const scope = context.req.query("scope");
+      if (
+        scope !== "overview" &&
+        scope !== "quick" &&
+        scope !== "detail" &&
+        scope !== "board" &&
+        scope !== "classification"
+      )
+        return headOrJson(context, (await readSnapshot(context)).operations);
+      const layout = await readLayout();
+      const layoutMs = performance.now() - requestStartedAt;
       const { from, to } = projectionPeriodFilter(context);
-      const projection = await buildCanonicalOperationsProjection(
-        filesystem,
-        layout,
-        { from, to },
-        context.req.query("scope") === "overview",
-      );
-      return headOrJson(context, projection);
+      if (scope === "board") {
+        const stage = boardStage(context.req.query("stage"));
+        const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+        const limit = Math.min(
+          50,
+          Math.max(1, Number.parseInt(context.req.query("limit") ?? "10", 10) || 10),
+        );
+        const board = await readAggregate(
+          `operations:board:${from ?? ""}:${to ?? ""}`,
+          async () => {
+            const projection = await buildFirstFoldQuickProjection(
+              filesystem,
+              layout,
+              { from, to },
+              { includeBoardTasks: true },
+            );
+            return {
+              projection,
+              priority: await readWorkPriority(canonicalFilesystem, knownWorkIds(projection)),
+            };
+          },
+        );
+        const filters = boardFilters(context);
+        const pageKey = JSON.stringify({ from, to, stage, offset, limit, ...filters });
+        const page = await readAggregate(`operations:board-page:${pageKey}`, async () =>
+          boardPage(board.projection, stage, offset, limit, board.priority.item_ids, filters),
+        );
+        return headOrJson(context, page, 200, true);
+      }
+      if (scope === "classification") {
+        const kind = context.req.query("kind");
+        const classification = context.req.query("classification");
+        if (kind !== "task" && kind !== "spec" && kind !== "prd")
+          return headOrJson(context, { error: "A valid work kind is required" }, 400);
+        if (
+          !["lite", "standard", "critical", "empty", "structured", "rework"].includes(
+            classification ?? "",
+          )
+        )
+          return headOrJson(context, { error: "A valid classification is required" }, 400);
+        const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+        const limit = Math.min(
+          50,
+          Math.max(1, Number.parseInt(context.req.query("limit") ?? "50", 10) || 50),
+        );
+        const projection = await readAggregate(
+          `operations:classification:${from ?? ""}:${to ?? ""}`,
+          () =>
+            buildFirstFoldQuickProjection(
+              filesystem,
+              layout,
+              { from, to },
+              { includeBoardTasks: true },
+            ),
+        );
+        return headOrJson(
+          context,
+          classificationPage(
+            projection,
+            kind,
+            classification as BoardClassification,
+            offset,
+            limit,
+          ),
+          200,
+          true,
+        );
+      }
+      if (scope === "quick") {
+        const projectionStartedAt = performance.now();
+        const quick = await readAggregate(
+          `operations:quick:${from ?? ""}:${to ?? ""}`,
+          () =>
+            buildFirstFoldQuickProjection(
+              filesystem,
+              layout,
+              { from, to },
+              {
+                includeTopTasks: from === null && to === null,
+              },
+            ),
+          context.req.query("fresh") === "1",
+        );
+        if (
+          process.env.ZAIP_DASHBOARD_PROFILE_FIRST_FOLD === "1" &&
+          filesystem instanceof SqliteReadModelFileSystem
+        ) {
+          const timings = filesystem.firstFoldViewportProfile();
+          context.header(
+            "Server-Timing",
+            [
+              `layout;dur=${Math.round(layoutMs * 10) / 10}`,
+              `projection;dur=${Math.round((performance.now() - projectionStartedAt) * 10) / 10}`,
+              ...Object.entries(timings).map(([name, duration]) => `${name};dur=${duration}`),
+            ].join(", "),
+          );
+        }
+        return headOrJson(context, quick, 200, true);
+      }
+      const projection =
+        filesystem instanceof SqliteReadModelFileSystem
+          ? await buildFirstFoldQuickProjection(
+              filesystem,
+              layout,
+              { from, to },
+              {
+                includeBoardTasks: scope === "detail",
+                includeExtended: scope === "detail" || scope === "overview",
+                includePeriods: scope === "detail" || scope === "overview",
+              },
+            )
+          : await buildCanonicalOperationsProjection(
+              filesystem,
+              layout,
+              { from, to },
+              scope === "overview",
+            );
+      return headOrJson(context, projection, 200, scope === "overview");
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
       return headOrJson(
@@ -440,6 +1138,146 @@ export function createDashboardApp(
     }
   });
 
+  registerOperationsRunsRoute(app, filesystem, readAggregate, headOrJson);
+
+  // Explicit SQL read-model API for the comparison dashboard. It never falls
+  // back to filesystem pagination, making first-fold/entity query plans
+  // inspectable while preserving the established Operations contracts.
+  app.on(["GET", "HEAD"], `${API_PREFIX}/sqlite-read-models`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(context, { error: "SQLite read model is not active" }, 409);
+    const kind = context.req.query("kind");
+    const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+    const limit = Math.min(
+      200,
+      Math.max(1, Number.parseInt(context.req.query("limit") ?? "20", 10) || 20),
+    );
+    if (kind === "overview") {
+      const period = context.req.query("period");
+      if (period !== "day" && period !== "month" && period !== "year")
+        return headOrJson(context, { error: "Unsupported SQLite overview period" }, 400);
+      return headOrJson(context, filesystem.overviewPage(period, offset, limit), 200, true);
+    }
+    if (kind !== "task" && kind !== "spec" && kind !== "prd")
+      return headOrJson(context, { error: "Unsupported SQLite read model" }, 400);
+    const { from, to } = projectionPeriodFilter(context);
+    const filters = operationsPageFilters(context);
+    return headOrJson(
+      context,
+      filesystem.summaryPage(
+        kind,
+        { from, to, ...filters },
+        offset,
+        limit,
+        context.req.query("cursor") ?? null,
+      ),
+      200,
+      true,
+    );
+  });
+
+  app.on(["GET", "HEAD"], `${API_PREFIX}/sqlite-views`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(context, { error: "SQLite read model is not active" }, 409);
+    const view = context.req.query("view");
+    if (view === undefined || !(view in sqliteViewMetadata))
+      return headOrJson(context, { error: "Unsupported SQLite view" }, 400);
+    const parsed = Number.parseInt(context.req.query("limit") ?? "", 10);
+    const defaultLimit = view.includes("agent_invocations")
+      ? 100
+      : view === "first_fold_top_tasks"
+        ? 5
+        : 50;
+    const limit = Math.min(200, Math.max(1, Number.isFinite(parsed) ? parsed : defaultLimit));
+    const { from, to } = projectionPeriodFilter(context);
+    const optional = (name: string) => {
+      const value = context.req.query(name);
+      return value === undefined ? {} : { [name]: value };
+    };
+    return headOrJson(
+      context,
+      filesystem.viewPage(view as keyof typeof sqliteViewMetadata, {
+        from,
+        to,
+        ...optional("query"),
+        ...optional("status"),
+        ...optional("risk"),
+        ...optional("provider"),
+        ...optional("model"),
+        ...optional("agent"),
+        ...optional("phase"),
+        ...optional("origin"),
+        ...optional("workType"),
+        ...optional("priority"),
+        offset: Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0),
+        limit,
+      }),
+      200,
+      true,
+    );
+  });
+
+  app.on(["GET", "HEAD"], `${API_PREFIX}/work-priority`, async (context) => {
+    const layout = await requireV2Layout(canonicalFilesystem);
+    const operations = await buildOperationsProjection(canonicalFilesystem, layout, {
+      from: null,
+      to: null,
+    });
+    return headOrJson(
+      context,
+      await readWorkPriority(canonicalFilesystem, knownWorkIds(operations)),
+    );
+  });
+
+  app.on(["GET", "HEAD"], `${API_PREFIX}/operations/entities`, async (context) => {
+    const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+    const limit = Math.min(
+      500,
+      Math.max(1, Number.parseInt(context.req.query("limit") ?? "100", 10) || 100),
+    );
+    const kind = context.req.query("kind");
+    if (kind !== "changes" && kind !== "decisions")
+      return headOrJson(context, { error: "Unsupported Operations entity page" }, 400);
+    const { from, to } = projectionPeriodFilter(context);
+    const pageFilters = operationsPageFilters(context);
+    const payload = await readAggregate(
+      `operations:entities:${kind}:${from ?? ""}:${to ?? ""}:${offset}:${limit}:${pageFilters.query}:${pageFilters.status}:${pageFilters.risk}`,
+      async () => {
+        const layout = await readLayout();
+        const entities = await new LifecycleManifestStore(filesystem).readEntities(
+          kind === "changes" ? "change" : "decision",
+        );
+        const entityRows =
+          kind === "changes"
+            ? changeEntityPageRows(entities, layout, from, to)
+            : decisionEntityPageRows(entities, layout, from, to);
+        const rows = filterLifecyclePageRows(entityRows, pageFilters);
+        return {
+          data_source: "lifecycle_manifest_shards",
+          kind,
+          offset,
+          limit,
+          total: rows.length,
+          rows: rows.slice(offset, offset + limit),
+        };
+      },
+    );
+    return headOrJson(context, payload, 200, true);
+  });
+
+  registerDailyReadModelRoute(app, filesystem, readAggregate, headOrJson);
+  app.put(`${API_PREFIX}/work-priority`, async (context) => {
+    const candidate = normalizeWorkPriority(await context.req.json());
+    // Priority is canonical queue configuration, never snapshot content.
+    // Keep every other settings mutation blocked in snapshot-serving mode.
+    await canonicalFilesystem.writeTextAtomic(
+      WORK_PRIORITY_PATH,
+      `${JSON.stringify(candidate, null, 2)}\n`,
+    );
+    clearSnapshotCache();
+    return context.json(candidate);
+  });
+
   app.on(["GET", "HEAD"], `${API_PREFIX}/snapshot`, async (context) => {
     try {
       return headOrJson(context, await readSnapshot(context));
@@ -455,10 +1293,14 @@ export function createDashboardApp(
 
   app.post(`${API_PREFIX}/reconcile-open-work`, async (context) => {
     try {
-      await requireV2Layout(filesystem);
-      const reconciledIds = await reconcileOpenWork(filesystem, workspaceRoot);
+      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.
+      const reconciledIds = await reconcileOpen(canonicalFilesystem, workspaceRoot);
+      await rebuildProjection();
       return context.json({
-        ...(await dashboardSnapshot(filesystem, workspaceRoot, context)),
+        ...(await readSnapshot(context)),
         reconciliation: reconciledIds,
       });
     } catch (error) {
@@ -467,9 +1309,87 @@ export function createDashboardApp(
     }
   });
 
+  app.post(`${API_PREFIX}/refresh-projection`, async (context) => {
+    try {
+      await readLayout();
+      await rebuildProjection();
+      return context.json(await readSnapshot(context));
+    } catch (error) {
+      if (error instanceof V2WorkspaceRequiredError) throw error;
+      return context.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+    }
+  });
+
   app.on(["GET", "HEAD"], `${API_PREFIX}/cost-monitor`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const scope = context.req.query("scope") ?? "summary";
+      if (scope === "summary") {
+        const layout = await readLayout();
+        const { from, to } = projectionPeriodFilter(context);
+        const currency = selectedCurrency(context);
+        const aggregateStartedAt = performance.now();
+        const [source, rate] = await Promise.all([
+          firstFoldCostSource(filesystem, {
+            from,
+            to,
+            providers: queryValues(context, "provider"),
+            models: queryValues(context, "model"),
+            agents: queryValues(context, "agent"),
+            phases: queryValues(context, "phase"),
+            statuses: queryValues(context, "status"),
+            tasks: queryValues(context, "task"),
+            specs: queryValues(context, "spec"),
+            prds: queryValues(context, "prd"),
+            executions: queryValues(context, "execution"),
+            changes: queryValues(context, "change"),
+          }),
+          currency === "BRL" ? readCurrentFxRate(filesystem) : Promise.resolve(null),
+        ]);
+        // First fold receives only aggregate facts. Detailed Runs and entity
+        // arrays remain on their explicit paginated endpoints.
+        const aggregateMs = performance.now() - aggregateStartedAt;
+        const costOperations = {
+          schema_version: 1,
+          layout_version: layout.version,
+          readonly: true,
+          source: ".agents/records",
+          filters: { from, to },
+          summary: { task_count: source.task_count ?? 0 },
+          prds: [],
+          specs: [],
+          runs: [],
+        } as unknown as OperationsProjection;
+        const projectionStartedAt = performance.now();
+        const payload = buildCostSummaryProjection(
+          source,
+          costOperations,
+          currency,
+          rate?.rate ?? null,
+        );
+        context.header(
+          "Server-Timing",
+          `cost_sql;dur=${aggregateMs.toFixed(1)},cost_projection;dur=${(performance.now() - projectionStartedAt).toFixed(1)}`,
+        );
+        return headOrJson(context, payload, 200, true);
+      }
+      if (scope === "runs") {
+        const layout = await readLayout();
+        const { from, to } = projectionPeriodFilter(context);
+        const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+        const limit = Math.min(
+          500,
+          Math.max(1, Number.parseInt(context.req.query("limit") ?? "100", 10) || 100),
+        );
+        return headOrJson(
+          context,
+          await buildManifestCostRunPage(filesystem, layout, context, { from, to }, offset, limit),
+          200,
+          true,
+        );
+      }
+      if (isUnfilteredCostRequest(context))
+        return headOrJson(context, (await readSnapshot(context)).costs);
+      const layout = await readLayout();
       const { from, to } = projectionPeriodFilter(context);
       // Cost and Operations must start from the same manifest-corrected Run
       // population; financial availability is represented on each row, never
@@ -507,6 +1427,7 @@ export function createDashboardApp(
       ".agents/config/pricing/models.json",
       `${JSON.stringify(catalog, null, 2)}\n`,
     );
+    clearSnapshotCache();
     return context.json(catalog);
   });
 
@@ -518,6 +1439,7 @@ export function createDashboardApp(
   app.put(`${API_PREFIX}/fx-rate`, async (context) => {
     const input = fxRateSchema.pick({ rate: true }).parse(await context.req.json());
     const rate = await new PricingRepository(filesystem).writeCurrentFxRate(input.rate);
+    clearSnapshotCache();
     return context.json(rate);
   });
 
@@ -553,9 +1475,13 @@ export function createDashboardApp(
   app.put(`${API_PREFIX}/agent-catalog`, async (context) => {
     const update = async () => {
       try {
-        return context.json(
-          await persistAgentCatalogUpdate(filesystem, await context.req.json(), syncAgentAdapters),
+        const persisted = await persistAgentCatalogUpdate(
+          filesystem,
+          await context.req.json(),
+          syncAgentAdapters,
         );
+        clearSnapshotCache();
+        return context.json(persisted);
       } catch (error) {
         if (error instanceof AgentCatalogUpdateError) {
           return context.json({ error: error.message }, error.status);
@@ -573,7 +1499,7 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/project-settings`, async (context) => {
     try {
-      return headOrJson(context, await readProjectSettings(filesystem));
+      return headOrJson(context, await readProjectSettings(canonicalFilesystem));
     } catch (error) {
       return headOrJson(
         context,
@@ -583,9 +1509,15 @@ export function createDashboardApp(
     }
   });
 
+  app.on(["GET", "HEAD"], `${API_PREFIX}/project-settings/overview`, async (context) => {
+    return headOrJson(context, await readProjectOverview(canonicalFilesystem));
+  });
+
   app.put(`${API_PREFIX}/project-settings`, async (context) => {
     try {
-      return context.json(await persistProjectSettings(filesystem, await context.req.json()));
+      const persisted = await persistProjectSettings(canonicalFilesystem, await context.req.json());
+      clearSnapshotCache();
+      return context.json(persisted);
     } catch (error) {
       return context.json(
         { error: error instanceof Error ? error.message : "Project settings update failed" },
@@ -596,7 +1528,7 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/tasks/:id`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const layout = await readLayout();
       return headOrJson(context, await readTaskDetail(filesystem, layout, context.req.param("id")));
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
@@ -606,7 +1538,7 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/prds/:id`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const layout = await readLayout();
       return headOrJson(context, await readPrdDetail(filesystem, layout, context.req.param("id")));
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
@@ -616,7 +1548,7 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/specs/:id`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
+      const layout = await readLayout();
       return headOrJson(context, await readSpecDetail(filesystem, layout, context.req.param("id")));
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
@@ -626,8 +1558,14 @@ export function createDashboardApp(
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/tasks/:id/trace`, async (context) => {
     try {
-      const layout = await requireV2Layout(filesystem);
-      return headOrJson(context, await buildTaskTrace(filesystem, layout, context.req.param("id")));
+      const layout = await readLayout();
+      const taskId = context.req.param("id");
+      return headOrJson(
+        context,
+        filesystem instanceof SqliteReadModelFileSystem
+          ? buildSqliteTaskTrace(filesystem, layout, taskId)
+          : await buildTaskTrace(filesystem, layout, taskId),
+      );
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
       return headOrJson(context, { error: "Task trace not found" }, 404);
@@ -657,57 +1595,28 @@ export function createDashboardApp(
   return app;
 }
 
-async function runAgentAdapterSync(workspaceRoot: string): Promise<AgentAdapterSyncResult> {
-  const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
-  const commandOptions = {
-    cwd: workspaceRoot,
-    encoding: "utf8" as const,
-    windowsHide: true,
-    timeout: 120_000,
-    maxBuffer: 10 * 1_024 * 1_024,
-  };
-  await execFileAsync(process.execPath, [cliPath, "adapters", "build", "--json"], commandOptions);
-  const { stdout } = await execFileAsync(
-    process.execPath,
-    [cliPath, "adapters", "check", "--json"],
-    commandOptions,
-  );
-  const result = JSON.parse(stdout) as { valid?: unknown; drifted?: unknown };
-  return {
-    valid: result.valid === true,
-    drifted: Array.isArray(result.drifted)
-      ? result.drifted.filter((value): value is string => typeof value === "string")
-      : [],
-  };
-}
-
-/** Date-only filters in the dashboard represent complete calendar days. */
-export function projectionPeriodFilter(context: Pick<Context, "req">): {
-  from: string | null;
-  to: string | null;
-} {
-  const from = context.req.query("from") ?? null;
-  const to = context.req.query("to") ?? null;
-  return {
-    from: dateOnlyBoundary(from, "start"),
-    to: dateOnlyBoundary(to, "end"),
-  };
-}
-
-function dateOnlyBoundary(value: string | null, boundary: "start" | "end"): string | null {
-  if (value === null || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
-  return boundary === "start" ? `${value}T00:00:00.000Z` : `${value}T23:59:59.999Z`;
-}
-
 async function dashboardSnapshot(
   filesystem: WorkspaceFileSystem,
   workspaceRoot: string,
   context: Context,
+  cachedLayout?: WorkspaceLayout,
 ) {
-  const layout = await requireV2Layout(filesystem);
+  const layout = cachedLayout ?? (await requireV2Layout(filesystem));
   const { from, to } = projectionPeriodFilter(context);
-  const operations = await buildCanonicalOperationsProjection(filesystem, layout, { from, to });
-  const costs = await buildCurrentCostProjection(filesystem, operations, selectedCurrency(context));
+  const currency = selectedCurrency(context);
+  const operations =
+    filesystem instanceof SqliteReadModelFileSystem
+      ? await buildFirstFoldQuickProjection(filesystem, layout, { from, to })
+      : await buildCanonicalOperationsProjection(filesystem, layout, { from, to });
+  const costs =
+    filesystem instanceof SqliteReadModelFileSystem
+      ? buildCostSummaryProjection(
+          await firstFoldCostSource(filesystem, { from, to }),
+          operations,
+          currency,
+          currency === "BRL" ? ((await readCurrentFxRate(filesystem))?.rate ?? null) : null,
+        )
+      : await buildCurrentCostProjection(filesystem, operations, currency);
   return {
     operations,
     costs,
@@ -719,81 +1628,75 @@ async function dashboardSnapshot(
   };
 }
 
+const moduleStartedAt = performance.now();
+const sessionToken = defaultSessionToken();
+const runtimeWorkspaceRoot = process.env.ZAIP_WORKSPACE ?? process.cwd();
+
+let defaultApp: Hono | undefined;
+
 /**
- * Assemble Operations from the tracked lifecycle records and, when a bounded
- * period was requested, the signed InvocationSummary manifests for that same
- * period.  Runtime projections are deliberately not read or cached here.
+ * Compatibility export for direct module consumers. The executable must not
+ * construct this filesystem-backed app: `main` creates the SQLite app after
+ * its private read model is ready. Construct on first consumer access instead.
  */
-async function buildCanonicalOperationsProjection(
-  filesystem: WorkspaceFileSystem,
-  layout: WorkspaceLayout,
-  filter: { from: string | null; to: string | null },
-  overviewOnly = false,
-) {
-  const operations = await buildOperationsProjection(filesystem, layout, filter, { overviewOnly });
-  if (overviewOnly || filter.from === null || filter.to === null) return operations;
-  const summaries = await invocationSummariesForPeriod(filesystem, {
-    from: filter.from,
-    to: filter.to,
-  });
-  return summaries.length === 0
-    ? operations
-    : recalculateOperationsRunSummary({
-        ...operations,
-        runs: projectExecutionDurations(mergeManifestRuns(operations.runs, summaries)),
-      });
+export function defaultDashboardApp(): Hono {
+  defaultApp ??= createDashboardApp(runtimeWorkspaceRoot, sessionToken);
+  return defaultApp;
 }
 
-async function buildCurrentCostProjection(
-  filesystem: WorkspaceFileSystem,
-  operations: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
-  currency: "BRL" | "USD",
-) {
-  const pricing = new PricingRepository(filesystem);
-  const [catalog, fxRate] = await Promise.all([
-    pricing.readCatalog(),
-    currency === "BRL" ? pricing.readLatestFxRate() : Promise.resolve(null),
-  ]);
-  const agentNames = await configuredAgentNames(filesystem);
-  return buildCostMonitorProjection(operations, { catalog, fxRate, currency }, agentNames);
-}
+export const app = new Proxy({} as Hono, {
+  get(_target, property) {
+    const value = Reflect.get(defaultDashboardApp(), property);
+    return typeof value === "function" ? value.bind(defaultDashboardApp()) : value;
+  },
+});
 
-async function buildManifestFirstCostProjection(
-  filesystem: WorkspaceFileSystem,
-  operations: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
-  context: Context,
-) {
-  const from = context.req.query("from") ?? null;
-  const to = context.req.query("to") ?? null;
-  if (from === null || to === null) {
-    return buildCurrentCostProjection(filesystem, operations, selectedCurrency(context));
-  }
-  const filters = {
-    providers: queryValues(context, "provider"),
-    models: queryValues(context, "model"),
-    zaip_agents: queryValues(context, "agent"),
-    phases: queryValues(context, "phase"),
-    statuses: queryValues(context, "status"),
-  };
-  const summaries = await invocationSummariesForPeriod(filesystem, { from, to, filters });
-  if (summaries.length === 0)
-    return buildCurrentCostProjection(filesystem, operations, selectedCurrency(context));
-  const runs = projectExecutionDurations(mergeManifestRuns(operations.runs, summaries));
-  return buildCurrentCostProjection(filesystem, { ...operations, runs }, selectedCurrency(context));
+function startupPhase(phase: string): void {
+  process.stderr.write(
+    `${JSON.stringify({
+      event: "dashboard_sqlite_startup_phase",
+      phase,
+      elapsed_ms: Math.round(performance.now() - moduleStartedAt),
+    })}\n`,
+  );
 }
 
-const sessionToken = defaultSessionToken();
-export const app = createDashboardApp(process.env.ZAIP_WORKSPACE ?? process.cwd(), sessionToken);
-
-const isMain = process.argv[1]
-  ? resolve(process.argv[1]) === fileURLToPath(import.meta.url)
-  : false;
-
-if (isMain) {
+async function main(): Promise<void> {
   const port = Number.parseInt(process.env.ZAIP_SERVER_PORT ?? "4317", 10);
-  serve({ fetch: app.fetch, hostname: HOST, port }, ({ port: boundPort }) => {
+  startupPhase("main_entered");
+  const startedAt = performance.now();
+  const readModel = await rebuildSqliteReadModel(runtimeWorkspaceRoot);
+  // The parent launcher captures stderr even when stdout is intentionally
+  // hidden. This makes seed hit/miss and private-copy cost observable without
+  // exposing a shared handle or workspace payload.
+  process.stderr.write(
+    `${JSON.stringify({
+      event: "dashboard_sqlite_read_model",
+      elapsed_ms: Math.round(performance.now() - startedAt),
+      cache: readModel.cache,
+      fingerprint_ms: readModel.fingerprint_ms,
+      materialize_ms: readModel.materialize_ms,
+      source_files: readModel.files,
+    })}\n`,
+  );
+  startupPhase("read_model_ready");
+  const runtimeApp = createDashboardApp(runtimeWorkspaceRoot, sessionToken, undefined, {
+    filesystem: new SqliteReadModelFileSystem(runtimeWorkspaceRoot),
+    snapshotState: readModel.cache === "stale_seed" ? "updating" : "current",
+  });
+  startupPhase("runtime_app_ready");
+  serve({ fetch: runtimeApp.fetch, hostname: HOST, port }, ({ port: boundPort }) => {
+    startupPhase("listening");
     process.stdout.write(
       `ZAIP-AIOS dashboard API: http://${HOST}:${boundPort}${API_PREFIX}/health\n`,
     );
   });
 }
+
+if (
+  process.argv[1]?.endsWith("server.cjs") ||
+  process.argv[1]?.endsWith("server.js") ||
+  process.argv[1]?.endsWith("server.mjs")
+) {
+  void main();
+}