@zaip-ai/cli 4.9.0 → 5.0.0

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

@@ -1,6 +1,5 @@
 import type { WorkspaceFileSystem, WorkspaceLayout } from "@zaip-ai/core";
 import { PricingRepository, queryInvocationManifestPage } from "@zaip-ai/costs";
-import type { CostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/contracts";
 import { buildCostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/server";
 import type { RunProjection } from "@zaip-ai/dashboard-operations/contracts";
 import {
@@ -10,6 +9,7 @@ import {
 } from "@zaip-ai/dashboard-operations/server";
 import type { Context } from "hono";
 import { mergeManifestRuns } from "./manifest-runs.js";
+import { filterCompactCostRuns } from "./server-cost-run-search.js";
 import {
   configuredAgentNames,
   invocationSummariesForPeriod,
@@ -190,18 +190,21 @@ export async function buildManifestCostRunPage(
     // API callers may request Run terminal status; absent telemetry never
     // matches an explicit status and remains visible only without this filter.
     filters.statuses.length > 0;
-  const [operations, page, lifecycleSummary] = await Promise.all([
+  const [operations, lifecycleSummary] = await Promise.all([
     // This compact projection reads the durable manifest summary plus Tasks;
     // it intentionally does not materialise Run records.
     import("@zaip-ai/dashboard-operations/server").then(({ buildQuickOperationsProjection }) =>
-      buildQuickOperationsProjection(filesystem, layout, { from, to }),
+      buildQuickOperationsProjection(filesystem, layout, { from, to }, { includeBoardTasks: true }),
     ),
-    queryInvocationManifestPage(filesystem, { from, to, filters, offset, limit }),
     filesystem
       .readText(".agents/records/lifecycle/summary.json")
       .then((value) => JSON.parse(value) as { run_metrics?: CompactRunMetric[] }),
   ]);
-  const compactRuns = (lifecycleSummary.run_metrics ?? [])
+  const compactRuns = filterCompactCostRuns(
+    lifecycleSummary.run_metrics ?? [],
+    context.req.query("query") ?? "",
+    operations.tasks,
+  )
     .filter((run) => runTimestampInRange(run.finished_at ?? run.started_at, from, to))
     .sort(
       (left, right) =>
@@ -215,6 +218,16 @@ export async function buildManifestCostRunPage(
     filters.phases.length === 0
       ? compactRuns
       : compactRuns.filter((run) => run.phase !== null && filters.phases.includes(run.phase));
+  const page = await queryInvocationManifestPage(filesystem, {
+    from,
+    to,
+    filters,
+    offset,
+    limit,
+    ...(context.req.query("query")
+      ? { runIds: new Set(lifecycleCandidates.map((run) => run.id)) }
+      : {}),
+  });
   const telemetryRunIds = new Set(page.summaries.map((summary) => summary.run_id));
   const baseRuns = hasTelemetryFilters
     ? // Provider/model/agent filters are telemetry dimensions. Their candidate
@@ -284,6 +297,8 @@ export function mergeLifecycleRunPage(
 
 export interface CompactRunMetric {
   id: string;
+  entrypoint?: string | null;
+  run_purpose?: string | null;
   started_at: string;
   finished_at: string | null;
   task_id: string | null;
@@ -334,11 +349,16 @@ export function compactRunProjection(run: CompactRunMetric): RunProjection {
         ? run.status
         : "completed",
     phase: run.phase ?? "execution",
-    entrypoint: run.task_id === null ? "conversation" : "task",
+    entrypoint:
+      run.entrypoint === "observation"
+        ? "observation"
+        : run.task_id === null
+          ? "conversation"
+          : "task",
     work_type: "new",
     run_role: run.run_kind === "subrun" ? "subagent" : "orchestrator",
     run_kind: run.run_kind ?? "run",
-    run_purpose: "execution",
+    run_purpose: run.run_purpose === "observation" ? "observation" : "execution",
     requires_finalizer: false,
     parent_run_id: run.parent_run_id,
     client: "unknown",
@@ -354,7 +374,7 @@ export function compactRunProjection(run: CompactRunMetric): RunProjection {
     terminal_call_count: null,
     failed_call_count: 0,
     cancelled_call_count: 0,
-    conversation_id: run.conversation_id ?? run.id,
+    conversation_id: run.entrypoint === "observation" ? null : (run.conversation_id ?? run.id),
     execution_id: run.execution_id,
     task_id: run.task_id,
     spec_id: run.spec_id,
@@ -415,69 +435,5 @@ function normalizeRunRangeBoundary(value: string, boundary: "start" | "end"): st
   return value;
 }
 
-/** Keeps Cost Run transport incremental without changing aggregate semantics. */
-export function pageCostRunRows(
-  projection: CostMonitorProjection,
-  offset: number,
-  limit: number,
-): CostMonitorProjection {
-  const safeOffset = Math.max(0, offset);
-  const safeLimit = Math.min(500, Math.max(1, limit));
-  return {
-    ...projection,
-    runs: projection.runs.slice(safeOffset, safeOffset + safeLimit),
-    run_page: {
-      offset: safeOffset,
-      limit: safeLimit,
-      total: projection.runs.length,
-      has_more: safeOffset + safeLimit < projection.runs.length,
-    },
-  };
-}
-
-/**
- * The Runs endpoint advertises these dimensions as server-side filters. Apply
- * them before offset pagination so the reported total and every page have the
- * same population. Aggregate fields intentionally retain their full filtered
- * projection semantics and are not derived from the transport page.
- */
-export function filterCostRunRows(
-  projection: CostMonitorProjection,
-  filters: {
-    provider: readonly string[];
-    model: readonly string[];
-    agent: readonly string[];
-    phase: readonly string[];
-    status: readonly string[];
-  },
-): CostMonitorProjection {
-  const includes = (values: readonly string[], value: string) =>
-    values.length === 0 || values.includes(value);
-  const provider = (value: string | null) => {
-    const normalized = value?.trim().toLowerCase();
-    return !normalized || normalized === "unknown" || normalized === "codex"
-      ? "openai"
-      : normalized;
-  };
-  return {
-    ...projection,
-    runs: projection.runs.filter(
-      (run) =>
-        includes(filters.provider, provider(run.provider)) &&
-        includes(filters.model, run.model) &&
-        includes(filters.agent, run.agent_name) &&
-        includes(filters.phase, run.phase) &&
-        includes(filters.status, run.task_status),
-    ),
-  };
-}
-
-export async function readCurrentFxRate(filesystem: WorkspaceFileSystem) {
-  return new PricingRepository(filesystem).readLatestFxRate();
-}
-
-export function isUnfilteredCostRequest(context: Context): boolean {
-  return ["provider", "model", "agent", "phase", "status"].every(
-    (name) => (context.req.queries(name)?.length ?? 0) === 0,
-  );
-}
+export { filterCostRunRows, pageCostRunRows } from "./server-cost-run-search.js";
+export { isUnfilteredCostRequest, readCurrentFxRate } from "./server-projection-loaders.js";

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

@@ -0,0 +1,42 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import { fxRateSchema, PricingRepository, pricingCatalogSchema } from "@zaip-ai/costs";
+import type { Hono } from "hono";
+import { API_PREFIX, headOrJson } from "./server-http-contracts.js";
+
+/** Keep mutable pricing routes together behind the dashboard session middleware. */
+export function registerPricingRoutes(
+  app: Hono,
+  filesystem: WorkspaceFileSystem,
+  clearSnapshotCache: () => void,
+): void {
+  app.on(["GET", "HEAD"], `${API_PREFIX}/pricing`, async (context) =>
+    headOrJson(
+      context,
+      pricingCatalogSchema.parse(
+        JSON.parse(await filesystem.readText(".agents/config/pricing/models.json")),
+      ),
+    ),
+  );
+  app.put(`${API_PREFIX}/pricing`, async (context) => {
+    const catalog = pricingCatalogSchema.parse({
+      ...(await context.req.json()),
+      updated_at: new Date().toISOString(),
+    });
+    await filesystem.writeTextAtomic(
+      ".agents/config/pricing/models.json",
+      `${JSON.stringify(catalog, null, 2)}\n`,
+    );
+    clearSnapshotCache();
+    return context.json(catalog);
+  });
+  app.on(["GET", "HEAD"], `${API_PREFIX}/fx-rate`, async (context) => {
+    const rate = await new PricingRepository(filesystem).readLatestFxRate();
+    return headOrJson(context, rate);
+  });
+  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);
+  });
+}

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

@@ -0,0 +1,60 @@
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDashboardApp, projectionPeriodFilter } from "./server.js";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+describe("dashboard route safety and calendar filters", () => {
+  it("serves only allowlisted canonical agent portraits", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const agentIds = [
+      "agent-orchestrator",
+      "agent-builder",
+      "agent-task-executor",
+      "agent-analyst",
+      "agent-finalizer",
+      "agent-reviewer",
+      "agent-integrator",
+      "agent-auditor",
+      "agent-text-summarizer",
+      "agent-data-analyst",
+      "agent-refactoring-specialist",
+      "agent-frontend",
+      "agent-backend",
+      "agent-website-developer",
+      "agent-designer",
+      "agent-cloud-engineer",
+      "agent-security-auditor",
+      "agent-marketing-analyst",
+    ];
+    for (const agentId of agentIds) {
+      const portrait = await app.request(
+        `/api/v2/agent-catalog-assets/${agentId}?token=test-session`,
+      );
+      expect(portrait.status, agentId).toBe(200);
+      expect(portrait.headers.get("content-type"), agentId).toBe("image/png");
+      expect((await portrait.arrayBuffer()).byteLength, agentId).toBeGreaterThan(1_000);
+    }
+    const traversal = await app.request(
+      "/api/v2/agent-catalog-assets/%2E%2E%2Fproject?token=test-session",
+    );
+    expect(traversal.status).toBe(404);
+  });
+  it("treats date-only dashboard filters as whole calendar days", () => {
+    const context = {
+      req: { query: (name: string) => (name === "from" ? "2026-07-10" : "2026-07-26") },
+    };
+    expect(projectionPeriodFilter(context as never)).toEqual({
+      from: "2026-07-10T03:00:00.000Z",
+      to: "2026-07-27T02:59:59.999Z",
+    });
+  });
+  it("uses the IANA Sao Paulo offset for historical date-only filters", () => {
+    const context = {
+      req: { query: (name: string) => (name === "from" ? "2018-02-16" : "2018-02-16") },
+    };
+    expect(projectionPeriodFilter(context as never)).toEqual({
+      from: "2018-02-16T02:00:00.000Z",
+      to: "2018-02-17T01:59:59.999Z",
+    });
+  });
+});

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

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { filterCompactCostRuns } from "./server-cost-run-search.js";
 import { compactRunProjection, runTimestampInRange } from "./server-projections.js";
 
 describe("dashboard run projections", () => {
@@ -8,7 +9,7 @@ describe("dashboard run projections", () => {
   });
 
   it("keeps a lifecycle Run with no InvocationSummary as a null-telemetry page row", () => {
-    const run = compactRunProjection({
+    const metric = {
       id: "RUN-NO-SUMMARY",
       started_at: "2026-08-07T02:59:59.999Z",
       finished_at: null,
@@ -30,7 +31,16 @@ describe("dashboard run projections", () => {
       cost: null,
       currency: null,
       events: null,
-    });
+    };
+    const run = compactRunProjection(metric);
+    const older = { ...metric, id: "RUN-OLDER", task_id: "TASK-OLDER" };
+    expect(
+      filterCompactCostRuns([metric, older], "older title", [
+        { id: "TASK-OLDER", title: "Older title" },
+      ]),
+    ).toEqual([older]);
+    expect(filterCompactCostRuns([metric, older], "no-summary", [])).toEqual([metric]);
+    expect(filterCompactCostRuns([metric, older], "missing", [])).toEqual([]);
     expect(run).toMatchObject({
       id: "RUN-NO-SUMMARY",
       duration_ms: null,

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

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { describe, expect, it, vi } from "vitest";
+import type { ActiveCodexTelemetryCapture } from "./active-codex-telemetry.js";
 import { createDashboardApp } from "./server.js";
 import { withSqliteReadModelFixture } from "./server.test-fixtures.js";
 
@@ -84,12 +85,13 @@ describe("recent telemetry command readiness", () => {
   it("cannot advertise current after a failed capture even when canonical projection succeeds", async () => {
     await withSqliteReadModelFixture("telemetry-failed", async ({ root, filesystem }) => {
       const commit = vi.fn(async () => undefined);
+      const capture = vi.fn(async (): Promise<ActiveCodexTelemetryCapture> => {
+        throw Object.assign(new Error("private command output"), { code: "ETIMEDOUT" });
+      });
       const app = createDashboardApp(root, "session", undefined, {
         filesystem,
         refreshReadModel: commit,
-        captureTelemetry: async () => {
-          throw new Error("transcript timed out");
-        },
+        captureTelemetry: capture,
       });
       const headers = { "x-zaip-session": "session" };
       await app.request("/api/v2/capture-telemetry", { method: "POST", headers });
@@ -98,7 +100,12 @@ describe("recent telemetry command readiness", () => {
       expect(await ready.json()).toMatchObject({
         status: "degraded",
         snapshot_state: "updating",
-        active_capture_failure: { code: "active_telemetry_capture_failed" },
+        active_capture_failure: {
+          code: "active_telemetry_capture_failed",
+          failure_kind: "timeout",
+          process_code: "ETIMEDOUT",
+          exit_code: null,
+        },
       });
       const manual = await app.request("/api/v2/refresh-projection", { method: "POST", headers });
       expect(manual.status).toBe(503);
@@ -106,6 +113,24 @@ describe("recent telemetry command readiness", () => {
         error: "Telemetry capture is unavailable",
         snapshot_state: "updating",
       });
+
+      capture.mockImplementation(async () => ({
+        captured_runs: 0,
+        captured_segments: 0,
+        manifest_state: "initialized" as const,
+        skipped_reason: "no_new_segments" as const,
+        catch_up_complete: true,
+        pending_runs: 0,
+        last_capture_at: new Date().toISOString(),
+      }));
+      await app.request("/api/v2/capture-telemetry", { method: "POST", headers });
+      await vi.waitFor(async () => {
+        const response = await app.request("/api/v2/ready", { headers });
+        expect(await response.json()).toMatchObject({
+          active_capture_failure: null,
+          active_capture: { catch_up_complete: true, pending_runs: 0 },
+        });
+      });
     });
   });
 });

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

@@ -8,6 +8,7 @@ export function createTelemetryProjectionRefresh(input: {
   onCaptureFailure?: (error: unknown) => void;
 }) {
   let inFlight: Promise<void> | null = null;
+  let capturing = false;
   let projecting = false;
   const refresh = (catchUp = false): Promise<void> => {
     if (inFlight !== null) {
@@ -19,11 +20,14 @@ export function createTelemetryProjectionRefresh(input: {
     inFlight = (async () => {
       try {
         if (input.capture !== undefined) {
+          capturing = true;
           const result = await input.capture();
           input.onCaptureSuccess?.(result);
         }
       } catch (error) {
         input.onCaptureFailure?.(error);
+      } finally {
+        capturing = false;
       }
       // Keep canonical records readable even when telemetry is unavailable.
       // The caller retains the capture failure separately from SQLite health.
@@ -40,5 +44,8 @@ export function createTelemetryProjectionRefresh(input: {
     get pending() {
       return inFlight !== null;
     },
+    get capturing() {
+      return capturing;
+    },
   };
 }

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

@@ -7,7 +7,6 @@ import {
   createDashboardApp,
   dashboardWorkspaceKey,
   manifestRun,
-  projectionPeriodFilter,
   SqliteReadModelFileSystem,
 } from "./server.js";
 import { invocationSummary, withSqliteReadModelFixture } from "./server.test-fixtures.js";
@@ -564,6 +563,57 @@ describe("dashboard backend", () => {
       rows: expect.any(Array),
     });
   });
+  it("serves Operations Run pages from the canonical summary when SQLite omits that file", async () => {
+    await withSqliteReadModelFixture(
+      "operations-canonical-summary",
+      async ({ root, filesystem }) => {
+        const summaryPath = join(root, ".agents/records/lifecycle/summary.json");
+        await mkdir(join(root, ".agents/records/lifecycle"), { recursive: true });
+        await writeFile(
+          summaryPath,
+          JSON.stringify({
+            schema_version: 1,
+            run_metrics: [
+              {
+                id: "RUN-CANONICAL",
+                started_at: "2026-10-06T03:00:00.000Z",
+                finished_at: null,
+                phase: "execution",
+                status: "completed",
+                parent_run_id: null,
+                total_tokens: null,
+                cost: null,
+              },
+            ],
+          }),
+        );
+        await expect(
+          filesystem.readText(".agents/records/lifecycle/summary.json"),
+        ).rejects.toMatchObject({ code: "ENOENT" });
+        const headers = { "x-zaip-session": "test-session" };
+        const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+        const response = await app.request("/api/v2/operations/runs?kind=runs&offset=0&limit=10", {
+          headers,
+        });
+        expect(response.status).toBe(200);
+        await expect(response.json()).resolves.toMatchObject({
+          data_source: "lifecycle_manifest_summary",
+          rows: [
+            { id: "RUN-CANONICAL", total_tokens: null, started_at: "2026-10-06T03:00:00.000Z" },
+          ],
+        });
+        await writeFile(summaryPath, "{invalid-json");
+        const invalid = createDashboardApp(root, "test-session", undefined, { filesystem });
+        const rejected = await invalid.request(
+          "/api/v2/operations/runs?kind=runs&offset=0&limit=10",
+          {
+            headers,
+          },
+        );
+        expect(rejected.status).toBe(500);
+      },
+    );
+  });
   it("serves a Cost Run transport page without materializing aggregate totals", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const headers = { "x-zaip-session": "test-session" };
@@ -602,57 +652,4 @@ describe("dashboard backend", () => {
     expect(page.runs.length).toBeLessThanOrEqual(1);
     expect(page.runs.every((run) => run.phase === "execution")).toBe(true);
   });
-  it("serves only allowlisted canonical agent portraits", async () => {
-    const app = createDashboardApp(workspaceRoot, "test-session");
-    const agentIds = [
-      "agent-orchestrator",
-      "agent-builder",
-      "agent-task-executor",
-      "agent-analyst",
-      "agent-finalizer",
-      "agent-reviewer",
-      "agent-integrator",
-      "agent-auditor",
-      "agent-text-summarizer",
-      "agent-data-analyst",
-      "agent-refactoring-specialist",
-      "agent-frontend",
-      "agent-backend",
-      "agent-website-developer",
-      "agent-designer",
-      "agent-cloud-engineer",
-      "agent-security-auditor",
-      "agent-marketing-analyst",
-    ];
-    for (const agentId of agentIds) {
-      const portrait = await app.request(
-        `/api/v2/agent-catalog-assets/${agentId}?token=test-session`,
-      );
-      expect(portrait.status, agentId).toBe(200);
-      expect(portrait.headers.get("content-type"), agentId).toBe("image/png");
-      expect((await portrait.arrayBuffer()).byteLength, agentId).toBeGreaterThan(1_000);
-    }
-    const traversal = await app.request(
-      "/api/v2/agent-catalog-assets/%2E%2E%2Fproject?token=test-session",
-    );
-    expect(traversal.status).toBe(404);
-  });
-  it("treats date-only dashboard filters as whole calendar days", () => {
-    const context = {
-      req: { query: (name: string) => (name === "from" ? "2026-07-10" : "2026-07-26") },
-    };
-    expect(projectionPeriodFilter(context as never)).toEqual({
-      from: "2026-07-10T03:00:00.000Z",
-      to: "2026-07-27T02:59:59.999Z",
-    });
-  });
-  it("uses the IANA Sao Paulo offset for historical date-only filters", () => {
-    const context = {
-      req: { query: (name: string) => (name === "from" ? "2018-02-16" : "2018-02-16") },
-    };
-    expect(projectionPeriodFilter(context as never)).toEqual({
-      from: "2018-02-16T02:00:00.000Z",
-      to: "2018-02-17T01:59:59.999Z",
-    });
-  });
 });

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

@@ -3,10 +3,10 @@ import { basename, resolve } from "node:path";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
-import { fxRateSchema, PricingRepository, pricingCatalogSchema } from "@zaip-ai/costs";
 import { type Context, Hono } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
 import { createDashboardDiagnostics } from "../dashboard-diagnostics.mjs";
+import { activeCaptureFailure as describeActiveCaptureFailure } from "./active-capture-failure.js";
 import {
   type ActiveCodexTelemetryCapture,
   captureRepositoryActiveCodexTelemetry,
@@ -37,6 +37,7 @@ import {
   registerReconciliationRoute,
 } from "./server-reconciliation-route.js";
 import { isAllowedDashboardAuthority } from "./server-request-authority.js";
+import { registerPricingRoutes } from "./server-route-handlers.js";
 import { refreshSqliteSnapshotInWorker } from "./server-snapshot-refresh.js";
 import { readCommittedSnapshotRevision } from "./server-snapshot-revision.js";
 import { startSnapshotSynchronization } from "./server-snapshot-synchronization.js";
@@ -188,14 +189,17 @@ export function createDashboardApp(
   };
   let observedSnapshotRevision: string | null = null;
   const projectionRefreshDiagnostics = createProjectionRefreshDiagnostics();
-  let activeCaptureFailure: { code: string; occurred_at: string; cause: string } | null = null;
+  let activeCaptureFailure: ReturnType<typeof describeActiveCaptureFailure> | null = null;
   let activeCapture: ActiveCodexTelemetryCapture | null = null;
   let activeCapturePending = false;
   let projectionRefreshInFlight: Promise<void> | null = null;
   let projectionRefreshRequested = false;
   const associatedRefreshJobs = new Set<string>();
-  const rebuildProjection = async (associatedJobId: string | null = null) => {
+  const rebuildProjection = async (associatedJobId: string | null = null): Promise<void> => {
     if (associatedJobId !== null) associatedRefreshJobs.add(associatedJobId);
+    // Capture writes canonical records. Watcher events from those writes must
+    // join the ordered pass, not launch a competing SQLite rebuild.
+    if (telemetryRefresh.capturing) return telemetryRefresh.refresh();
     if (projectionRefreshInFlight !== null) {
       projectionRefreshRequested = true;
       return projectionRefreshInFlight;
@@ -259,26 +263,34 @@ export function createDashboardApp(
       });
     return projectionRefreshInFlight;
   };
+  const captureTelemetry =
+    options.captureTelemetry ??
+    (isSqliteSnapshot &&
+    options.watchSources === true &&
+    process.env.ZAIP_DASHBOARD_WATCH_SOURCES !== "0"
+      ? () => captureRepositoryActiveCodexTelemetry(workspaceRoot)
+      : undefined);
   const telemetryRefresh = createTelemetryProjectionRefresh({
     refresh: rebuildProjection,
-    ...(options.captureTelemetry !== undefined
-      ? { capture: options.captureTelemetry }
-      : isSqliteSnapshot &&
-          options.watchSources === true &&
-          process.env.ZAIP_DASHBOARD_WATCH_SOURCES !== "0"
-        ? { capture: () => captureRepositoryActiveCodexTelemetry(workspaceRoot) }
-        : {}),
+    ...(captureTelemetry === undefined
+      ? {}
+      : {
+          capture: async () => {
+            // A source-only projection can precede the periodic capture. Drain it
+            // while the capture reservation prevents new watcher projections.
+            if (projectionRefreshInFlight !== null)
+              await projectionRefreshInFlight.catch(() => undefined);
+            return captureTelemetry();
+          },
+        }),
     onCaptureSuccess: (result) => {
       activeCapture = result;
       activeCaptureFailure = null;
       activeCapturePending = result.catch_up_complete === false;
     },
     onCaptureFailure: (error) => {
-      activeCaptureFailure = {
-        code: "active_telemetry_capture_failed",
-        occurred_at: new Date().toISOString(),
-        cause: error instanceof Error ? error.name : "unknown_error",
-      };
+      activeCaptureFailure = describeActiveCaptureFailure(error);
+      diagnostics.log("active_telemetry_capture_failed", activeCaptureFailure);
     },
   });
   const visibleSnapshotState = () =>
@@ -612,36 +624,7 @@ export function createDashboardApp(
     readAggregate,
     clearSnapshotCache,
   });
-  app.on(["GET", "HEAD"], `${API_PREFIX}/pricing`, async (context) =>
-    headOrJson(
-      context,
-      pricingCatalogSchema.parse(
-        JSON.parse(await filesystem.readText(".agents/config/pricing/models.json")),
-      ),
-    ),
-  );
-  app.put(`${API_PREFIX}/pricing`, async (context) => {
-    const catalog = pricingCatalogSchema.parse({
-      ...(await context.req.json()),
-      updated_at: new Date().toISOString(),
-    });
-    await filesystem.writeTextAtomic(
-      ".agents/config/pricing/models.json",
-      `${JSON.stringify(catalog, null, 2)}\n`,
-    );
-    clearSnapshotCache();
-    return context.json(catalog);
-  });
-  app.on(["GET", "HEAD"], `${API_PREFIX}/fx-rate`, async (context) => {
-    const rate = await new PricingRepository(filesystem).readLatestFxRate();
-    return headOrJson(context, rate);
-  });
-  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);
-  });
+  registerPricingRoutes(app, filesystem, clearSnapshotCache);
   registerAgentCatalogRoutes(app, {
     filesystem,
     workspaceRoot,

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

@@ -60,6 +60,11 @@ it.each([
     );
     await rebuildSqliteReadModel(root);
     fs = new SqliteReadModelFileSystem(root);
+    if (status === "completed") {
+      const fast = fs.viewPage("cost_monitor_agent_invocations", { query: "ainv-low", limit: 1 });
+      const sql = fs.viewPage("cost_monitor_agent_invocations", { query: "%AINV-LOW%", limit: 1 });
+      expect(fast).toEqual(sql);
+    }
     const summary = fs.costMonitorSummaryAggregate({ from: null, to: null });
     // Summary first paint remains aggregate-only, but its controls retain
     // factual filter choices from the same SQLite population.