@zaip-ai/cli 1.0.8 → 1.3.1

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

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