@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -1,7 +1,8 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { describe, expect, it } from "vitest";
+import { WorkspaceFileSystem } from "@zaip-ai/core";
+import { describe, expect, it, vi } from "vitest";
 import {
   createDashboardApp,
   dashboardWorkspaceKey,
@@ -13,10 +14,219 @@ import {
   reconciliationResult,
 } from "./server.js";
 import { invocationSummary } from "./server.test-fixtures.js";
+import { classificationPage } from "./server-board.js";
+import {
+  compactRunProjection,
+  mergeKnownManifestRuns,
+  mergeLifecycleRunPage,
+  runTimestampInRange,
+} from "./server-projections.js";
 
 const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
-
 describe("dashboard backend", () => {
+  it.each([
+    ["task", "lite", "TASK-LITE"],
+    ["task", "standard", "TASK-STANDARD"],
+    ["task", "critical", "TASK-CRITICAL"],
+    ["spec", "empty", "SPEC-EMPTY"],
+    ["spec", "structured", "SPEC-STRUCTURED"],
+    ["spec", "rework", "SPEC-REWORK"],
+    ["prd", "empty", "PRD-EMPTY"],
+    ["prd", "structured", "PRD-STRUCTURED"],
+    ["prd", "rework", "PRD-REWORK"],
+  ] as const)("returns only the canonical %s %s classification page", (kind, classification, expectedId) => {
+    const projection = {
+      tasks: [
+        { id: "TASK-LITE", risk: "lite", created_at: "2026-08-21T00:00:00.000Z", updated_at: null },
+        {
+          id: "TASK-STANDARD",
+          risk: "standard",
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+        {
+          id: "TASK-CRITICAL",
+          risk: "critical",
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+      ],
+      specs: [
+        {
+          id: "SPEC-EMPTY",
+          task_count: 0,
+          rework_run_count: 0,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+        {
+          id: "SPEC-STRUCTURED",
+          task_count: 1,
+          rework_run_count: 0,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+        {
+          id: "SPEC-REWORK",
+          task_count: 1,
+          rework_run_count: 1,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+      ],
+      prds: [
+        {
+          id: "PRD-EMPTY",
+          task_count: 0,
+          rework_run_count: 0,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+        {
+          id: "PRD-STRUCTURED",
+          task_count: 1,
+          rework_run_count: 0,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+        {
+          id: "PRD-REWORK",
+          task_count: 1,
+          rework_run_count: 1,
+          created_at: "2026-08-21T00:00:00.000Z",
+          updated_at: null,
+        },
+      ],
+      changes: [],
+    } as unknown as Parameters<typeof classificationPage>[0];
+
+    const page = classificationPage(projection, kind, classification, 0, 1);
+    const items = kind === "task" ? page.tasks : kind === "spec" ? page.specs : page.prds;
+
+    expect(page).toMatchObject({ offset: 0, total: 1 });
+    expect(items.map((item) => item.id)).toEqual([expectedId]);
+    expect(kind === "task" ? page.specs : page.tasks).toEqual([]);
+    expect(kind === "prd" ? page.specs : page.prds).toEqual([]);
+  });
+
+  it("keeps Runs on the final all-time summary day inside the page-first range", () => {
+    expect(runTimestampInRange("2026-08-07T23:59:59.000Z", "2026-08-01", "2026-08-07")).toBe(true);
+    expect(runTimestampInRange("2026-08-08T00:00:00.000Z", "2026-08-01", "2026-08-07")).toBe(false);
+  });
+  it("keeps a lifecycle Run with no InvocationSummary as a null-telemetry page row", () => {
+    const run = compactRunProjection({
+      id: "RUN-NO-SUMMARY",
+      started_at: "2026-08-07T02:59:59.999Z",
+      finished_at: null,
+      task_id: null,
+      execution_id: null,
+      conversation_id: null,
+      agent: null,
+      agent_name: null,
+      provider: null,
+      model: null,
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      phase: "execution",
+      parent_run_id: null,
+      status: "completed",
+      duration_ms: null,
+      total_tokens: null,
+      cost: null,
+      currency: null,
+      events: null,
+    });
+    expect(run).toMatchObject({
+      id: "RUN-NO-SUMMARY",
+      duration_ms: null,
+      source_duration_ms: null,
+    });
+    expect(run.usage.total.tokens.total).toBeNull();
+    expect(run.usage.total.cost.brl).toBeNull();
+  });
+  it("projects factual compact Run dimensions without replacing absent data", () => {
+    const run = compactRunProjection({
+      id: "RUN-FACTUAL-DIMENSIONS",
+      started_at: "2026-08-08T03:00:00.000Z",
+      finished_at: null,
+      task_id: "TASK-1",
+      execution_id: "EXEC-1",
+      conversation_id: "CONV-1",
+      agent: "agent-builder",
+      agent_name: "Builder",
+      provider: "openai",
+      model: "gpt-5.6",
+      spec_id: "SPEC-1",
+      prd_id: "PRD-1",
+      change_id: "CHG-1",
+      phase: "execution",
+      parent_run_id: null,
+      status: "completed",
+      run_kind: "run",
+      duration_ms: 12_000,
+      total_tokens: 42,
+      cost: 4.2,
+      currency: "BRL",
+      events: 1,
+    });
+    expect(run).toMatchObject({
+      agent: "agent-builder",
+      agent_name: "Builder",
+      provider: "openai",
+      model: "gpt-5.6",
+      effective_model: "gpt-5.6",
+      execution_id: "EXEC-1",
+      conversation_id: "CONV-1",
+      task_id: "TASK-1",
+      spec_id: "SPEC-1",
+      prd_id: "PRD-1",
+      change_id: "CHG-1",
+    });
+  });
+  it("left-joins telemetry without changing lifecycle page IDs or length", () => {
+    const page = ["RUN-PAGE-1", "RUN-PAGE-2"].map((id) =>
+      compactRunProjection({
+        id,
+        started_at: "2026-08-07T03:00:00.000Z",
+        finished_at: null,
+        task_id: null,
+        execution_id: null,
+        conversation_id: null,
+        agent: null,
+        agent_name: null,
+        provider: null,
+        model: null,
+        spec_id: null,
+        prd_id: null,
+        change_id: null,
+        phase: "execution",
+        parent_run_id: null,
+        status: "completed",
+        duration_ms: null,
+        total_tokens: null,
+        cost: null,
+        currency: null,
+        events: null,
+      }),
+    );
+    const result = mergeLifecycleRunPage(page, [
+      invocationSummary({ run_id: "RUN-PAGE-1" }),
+      invocationSummary({ run_id: "RUN-NOT-ON-PAGE" }),
+    ]);
+    expect(result).toHaveLength(2);
+    expect(result.map((run) => run.id)).toEqual(["RUN-PAGE-1", "RUN-PAGE-2"]);
+    expect(result[1]?.usage.total.tokens.total).toBeNull();
+  });
+  it("does not reintroduce a Run excluded by the canonical lifecycle period", () => {
+    const retained = invocationSummary({ run_id: "RUN-IN-PERIOD" });
+    const excluded = invocationSummary({ run_id: "RUN-OUTSIDE-PERIOD" });
+    expect(
+      mergeKnownManifestRuns([manifestRun(retained, [retained])], [retained, excluded]).map(
+        (run) => run.id,
+      ),
+    ).toEqual(["RUN-IN-PERIOD"]);
+  });
   it("normalizes GitHub HTTPS and SSH remotes for display", () => {
     expect(githubRepositoryFromRemote("git@github.com:zaip-ai/zaip-aios.git")).toBe(
       "zaip-ai/zaip-aios",
@@ -28,14 +238,12 @@ describe("dashboard backend", () => {
     expect(githubRepositoryFromRemote("")).toBeNull();
     expect(githubRepositoryFromRemote("https://gitlab.com/zaip-ai/zaip-aios.git")).toBeNull();
   });
-
   it("exposes a modern read-only health endpoint", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const response = await app.request("/api/v2/health");
-
     expect(response.status).toBe(200);
     await expect(response.json()).resolves.toMatchObject({
-      kind: "zaip-dashboard-local-runtime",
+      kind: "zaip-dashboard-sqlite-runtime",
       workspaceKey: dashboardWorkspaceKey(workspaceRoot),
       api_version: 2,
       read_only: true,
@@ -43,36 +251,242 @@ describe("dashboard backend", () => {
       workspace_layout: 3,
     });
   });
-
-  it("serves compact overview aggregates without Run detail", async () => {
-    const app = createDashboardApp(workspaceRoot, "test-session");
-    const response = await app.request("/api/v2/operations?scope=overview", {
+  it("permits canonical open-work reconciliation while serving a read-only SQLite snapshot", async () => {
+    const reconcile = vi.fn(async () => ({ reconciled_ids: ["TASK-RECONCILED"], blocked: [], not_reconciled: [] }));
+    const refresh = vi.fn(async () => undefined);
+    const canonicalFilesystem = new WorkspaceFileSystem(workspaceRoot);
+    const app = createDashboardApp(workspaceRoot, "test-session", undefined, {
+      snapshotReadOnly: true,
+      canonicalFilesystem,
+      reconcileOpenWork: reconcile,
+      refreshReadModel: refresh,
+    });
+    const response = await app.request("/api/v2/reconcile-open-work", {
+      method: "POST",
       headers: { "x-zaip-session": "test-session" },
     });
-
-    expect(response.status).toBe(200);
-    const payload = await response.json();
-    if (
-      typeof payload !== "object" ||
-      payload === null ||
-      !("summary" in payload) ||
-      typeof payload.summary !== "object" ||
-      payload.summary === null ||
-      !("overview_metrics" in payload.summary)
-    ) {
-      throw new Error("Operations overview payload is not an object with summary");
+    expect(response.status, await response.clone().text()).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      reconciliation: { reconciled_ids: ["TASK-RECONCILED"] },
+    });
+    expect(reconcile).toHaveBeenCalledOnce();
+    expect(reconcile).toHaveBeenCalledWith(canonicalFilesystem, workspaceRoot);
+    expect(refresh).toHaveBeenCalledOnce();
+    const rejected = await app.request("/api/v2/reconcile-open-work", { method: "POST" });
+    expect(rejected.status).toBe(401);
+  }, 130_000);
+  it("persists Kanban priority canonically while a SQLite snapshot blocks other settings writes", async () => {
+    const canonicalRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-priority-"));
+    try {
+      const canonicalFilesystem = new WorkspaceFileSystem(canonicalRoot);
+      const originalReadText = canonicalFilesystem.readText.bind(canonicalFilesystem);
+      const priorityReads = vi.fn(async (path: string) => originalReadText(path));
+      vi.spyOn(canonicalFilesystem, "readText").mockImplementation(priorityReads);
+      const app = createDashboardApp(workspaceRoot, "test-session", undefined, {
+        snapshotReadOnly: true,
+        canonicalFilesystem,
+      });
+      const before = await app.request(
+        "/api/v2/operations?scope=board&stage=completed&from=2000-01-01&to=2099-12-31&offset=0&limit=10",
+        { headers: { "x-zaip-session": "test-session" } },
+      );
+      expect(before.status, await before.clone().text()).toBe(200);
+      const beforeBoard = (await before.json()) as {
+        prds: Array<{ id: string }>;
+        specs: Array<{ id: string }>;
+        tasks: Array<{ id: string }>;
+      };
+      expect(beforeBoard.tasks.length).toBeGreaterThan(1);
+      const concurrent = await Promise.all([
+        app.request("/api/v2/operations?scope=board&stage=completed&from=2000-01-01&to=2099-12-31&offset=0&limit=10", { headers: { "x-zaip-session": "test-session" } }),
+        app.request("/api/v2/operations?scope=board&stage=blocked&from=2000-01-01&to=2099-12-31&offset=0&limit=10", { headers: { "x-zaip-session": "test-session" } }),
+      ]);
+      expect(concurrent.every((response) => response.status === 200)).toBe(true);
+      expect(priorityReads.mock.calls.filter(([path]) => path === ".agents/dashboard/work-priority.json")).toHaveLength(1);
+      const priority = { item_ids: [beforeBoard.tasks.at(-1)!.id], updated_at: null };
+      const persisted = await app.request("/api/v2/work-priority", {
+        method: "PUT",
+        headers: { "content-type": "application/json", "x-zaip-session": "test-session" },
+        body: JSON.stringify(priority),
+      });
+      expect(persisted.status, await persisted.clone().text()).toBe(200);
+      await expect(persisted.json()).resolves.toMatchObject({
+        schema_version: 1,
+        item_ids: priority.item_ids,
+      });
+      await expect(
+        canonicalFilesystem.readText(".agents/dashboard/work-priority.json"),
+      ).resolves.toContain(priority.item_ids[0]!);
+      const readsAfterPut = priorityReads.mock.calls.filter(
+        ([path]) => path === ".agents/dashboard/work-priority.json",
+      ).length;
+      const after = await app.request(
+        "/api/v2/operations?scope=board&stage=completed&from=2000-01-01&to=2099-12-31&offset=0&limit=10",
+        { headers: { "x-zaip-session": "test-session" } },
+      );
+      expect(after.status, await after.clone().text()).toBe(200);
+      const afterBoard = (await after.json()) as typeof beforeBoard;
+      expect(afterBoard.tasks[0]?.id).toBe(priority.item_ids[0]);
+      expect(priorityReads.mock.calls.filter(([path]) => path === ".agents/dashboard/work-priority.json").length).toBe(readsAfterPut + 1);
+      const blocked = await app.request("/api/v2/pricing", {
+        method: "PUT",
+        headers: { "content-type": "application/json", "x-zaip-session": "test-session" },
+        body: JSON.stringify({}),
+      });
+      expect(blocked.status).toBe(405);
+    } finally {
+      await rm(canonicalRoot, { recursive: true, force: true });
     }
-    expect(payload).toMatchObject({ runs: [], changes: [], executions: [], decisions: [] });
-    expect(payload.summary.overview_metrics).toEqual(
-      expect.objectContaining({
-        duration_ms: expect.any(Number),
-        execution_day_count: expect.any(Number),
-        tokens: expect.any(Number),
-        cost_brl: expect.any(Number),
-      }),
+  });
+  it("serves a cursor-sized Kanban stage from entity-only read models", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request(
+      "/api/v2/operations?scope=board&stage=completed&offset=0&limit=10",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      prds: unknown[];
+      specs: unknown[];
+      tasks: unknown[];
+    };
+    expect(payload).toMatchObject({
+      stage: "completed",
+      offset: 0,
+      total: expect.any(Number),
+      prds: expect.any(Array),
+      specs: expect.any(Array),
+      tasks: expect.any(Array),
+      changes: expect.any(Array),
+    });
+    expect(payload.prds.length + payload.specs.length + payload.tasks.length).toBeLessThanOrEqual(
+      10,
     );
   });
-
+  it("applies Kanban filters before pagination without requesting aggregate telemetry", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request(
+      "/api/v2/operations?scope=board&stage=blocked&offset=0&limit=10&risk=critical",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      total: number;
+      prds: unknown[];
+      specs: unknown[];
+      tasks: Array<{ risk: string }>;
+    };
+    expect(payload.prds).toEqual([]);
+    expect(payload.specs).toEqual([]);
+    expect(payload.tasks.every((task) => task.risk === "critical")).toBe(true);
+    expect(payload.tasks.length).toBeLessThanOrEqual(10);
+    expect(payload.total).toBeGreaterThanOrEqual(payload.tasks.length);
+  });
+  it("serves a canonical cross-stage classification page by work kind", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request(
+      "/api/v2/operations?scope=classification&kind=task&classification=critical&offset=0&limit=10",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      offset: number;
+      total: number;
+      tasks: Array<{ risk: string }>;
+      specs: unknown[];
+      prds: unknown[];
+    };
+    expect(payload).toMatchObject({ offset: 0, total: expect.any(Number), specs: [], prds: [] });
+    expect(payload.tasks.every((task) => task.risk === "critical")).toBe(true);
+    expect(payload.tasks.length).toBeLessThanOrEqual(10);
+  });
+  it("classifies SPEC pages from their canonical task and rework facts", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request(
+      "/api/v2/operations?scope=classification&kind=spec&classification=empty&offset=0&limit=10",
+      { headers: { "x-zaip-session": "test-session" } },
+    );
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as {
+      tasks: unknown[];
+      prds: unknown[];
+      specs: Array<{ task_count: number; rework_run_count: number }>;
+    };
+    expect(payload.tasks).toEqual([]);
+    expect(payload.prds).toEqual([]);
+    expect(payload.specs.every((spec) => spec.task_count === 0 && spec.rework_run_count === 0)).toBe(true);
+  });
+  it("serves a compact cost summary and paginated Run metrics from the manifest", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const headers = { "x-zaip-session": "test-session" };
+    const costs = await app.request("/api/v2/cost-monitor?currency=BRL&scope=summary", { headers });
+    expect(costs.status).toBe(200);
+    await expect(costs.json()).resolves.toMatchObject({
+      aggregate_only: true,
+      data_source: "lifecycle_manifest_summary",
+      runs: [],
+      groups: { daily: expect.any(Array), monthly: expect.any(Array), annual: expect.any(Array) },
+    });
+    const runs = await app.request("/api/v2/operations/runs?offset=0&limit=2", { headers });
+    expect(runs.status).toBe(200);
+    await expect(runs.json()).resolves.toMatchObject({
+      data_source: "lifecycle_manifest_summary",
+      offset: 0,
+      limit: 2,
+      rows: expect.any(Array),
+    });
+  });
+  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" };
+    const page = await app.request(
+      "/api/v2/cost-monitor?currency=BRL&scope=runs&offset=0&limit=1",
+      { headers },
+    );
+    expect(page.status).toBe(200);
+    const pagePayload = (await page.json()) as {
+      overview: { total_tokens: number | null };
+      runs: unknown[];
+      page_only: boolean;
+      run_page: { total: number | null };
+    };
+    expect(pagePayload.runs.length).toBeLessThanOrEqual(1);
+    expect(pagePayload.page_only).toBe(true);
+    expect(pagePayload.run_page.total).toBeGreaterThan(0);
+    expect(pagePayload.overview.total_tokens).toBeNull();
+  });
+  it("filters a Cost Run transport page by eligible provider model and phase dimensions", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const headers = { "x-zaip-session": "test-session" };
+    const query = new URLSearchParams({
+      currency: "BRL",
+      scope: "runs",
+      limit: "1",
+      phase: "execution",
+    });
+    const response = await app.request(`/api/v2/cost-monitor?${query.toString()}`, { headers });
+    expect(response.status).toBe(200);
+    const page = (await response.json()) as {
+      runs: Array<{ provider: string | null; model: string; phase: string }>;
+      run_page: { total: number | null };
+    };
+    expect(page.run_page.total).toBeGreaterThan(0);
+    expect(page.runs.length).toBeLessThanOrEqual(1);
+    expect(page.runs.every((run) => run.phase === "execution")).toBe(true);
+  });
+  it("serves operation detail without building the cost snapshot", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const response = await app.request("/api/v2/operations?scope=detail", {
+      headers: { "x-zaip-session": "test-session" },
+    });
+    expect(response.status).toBe(200);
+    expect(response.headers.get("X-ZAIP-Snapshot-Cache")).toBeNull();
+    await expect(response.json()).resolves.toMatchObject({
+      source: ".agents/records",
+      tasks: expect.any(Array),
+      runs: expect.any(Array),
+    });
+  });
   it("serves only allowlisted canonical agent portraits", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const agentIds = [
@@ -103,24 +517,29 @@ describe("dashboard backend", () => {
       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-10T00:00:00.000Z",
-      to: "2026-07-26T23:59:59.999Z",
+      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",
     });
   });
-
   it("dual-reads manifest summaries without losing legacy runs, costs, coverage, or hierarchy", () => {
     const root = invocationSummary({
       agent_invocation_id: "AINV-ROOT",
@@ -139,11 +558,9 @@ describe("dashboard backend", () => {
     });
     const legacyRoot = { ...manifestRun(root, [root, child]), client_thread_id: "legacy-thread" };
     const legacyOnly = { ...legacyRoot, id: "RUN-LEGACY" };
-
     const merged = mergeManifestRuns([legacyRoot, legacyOnly], [root, child]);
     const mergedRoot = merged.find((run) => run.id === "RUN-ROOT");
     const mergedChild = merged.find((run) => run.id === "RUN-CHILD");
-
     expect(merged).toHaveLength(3);
     expect(mergedRoot).toMatchObject({
       client_thread_id: "legacy-thread",
@@ -162,7 +579,50 @@ describe("dashboard backend", () => {
       parent_run_id: "RUN-ROOT",
     });
   });
-
+  it("keeps lifecycle calendar and accounting authoritative while enriching dimensions", () => {
+    const summary = invocationSummary({ run_id: "RUN-CANONICAL" });
+    summary.occurred_at = "2026-08-08T03:10:00.000Z";
+    const projected = manifestRun(summary, [summary]);
+    const legacy = {
+      ...projected,
+      started_at: "2026-08-07T02:57:00.000Z",
+      finished_at: "2026-08-07T03:06:00.000Z",
+      provider: null,
+      usage: {
+        ...projected.usage,
+        total: {
+          ...projected.usage.total,
+          tokens: { ...projected.usage.total.tokens, total: 999 },
+          cost: { usd: 1, brl: 9 },
+        },
+      },
+    };
+    expect(mergeManifestRuns([legacy], [summary])[0]).toMatchObject({
+      started_at: "2026-08-07T02:57:00.000Z",
+      finished_at: "2026-08-07T03:06:00.000Z",
+      provider: "openai",
+      usage: { total: { tokens: { total: 999 }, cost: { brl: 9 } } },
+    });
+  });
+  it("enriches a missing lifecycle token breakdown without replacing known accounting", () => {
+    const summary = invocationSummary({ run_id: "RUN-TOKEN-DETAIL" });
+    const projected = manifestRun(summary, [summary]);
+    const legacy = {
+      ...projected,
+      usage: {
+        ...projected.usage,
+        total: {
+          ...projected.usage.total,
+          tokens: { ...projected.usage.total.tokens, input: null, total: null },
+        },
+      },
+    };
+    const merged = mergeManifestRuns([legacy], [summary])[0]!;
+    expect(merged.usage.total.tokens).toMatchObject({
+      input: projected.usage.total.tokens.input,
+      total: projected.usage.total.tokens.total,
+    });
+  });
   it("retains bounded lifecycle duration when a manifest summary has no duration", () => {
     const summary = invocationSummary();
     summary.time.duration_ms = null;
@@ -182,9 +642,7 @@ describe("dashboard backend", () => {
       source_finished_at: "2026-07-26T12:00:00.000Z",
       capture_lag_ms: 12_000,
     };
-
     const merged = mergeManifestRuns([legacy], [summary]);
-
     expect(merged[0]).toMatchObject({
       duration_ms: 12_000,
       source_duration_ms: null,
@@ -193,7 +651,6 @@ describe("dashboard backend", () => {
       capture_lag_ms: null,
     });
   });
-
   it("does not let an unavailable manifest duration erase recovered source timing", () => {
     const summary = invocationSummary();
     summary.time.duration_ms = null;
@@ -205,7 +662,6 @@ describe("dashboard backend", () => {
       source_finished_at: "2026-07-26T12:00:12.000Z",
       capture_lag_ms: 0,
     };
-
     expect(mergeManifestRuns([legacy], [summary])[0]).toMatchObject({
       duration_ms: 12_000,
       source_duration_ms: 12_000,
@@ -213,15 +669,12 @@ describe("dashboard backend", () => {
       source_finished_at: "2026-07-26T12:00:12.000Z",
     });
   });
-
   it("rejects mutating methods before route dispatch", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const response = await app.request("/api/v2/operations", { method: "POST" });
-
     expect(response.status).toBe(405);
     expect(response.headers.get("allow")).toBe("GET, HEAD");
   });
-
   it("selects only entities represented in open work stages for reconciliation", () => {
     expect(
       openWorkIds([
@@ -237,7 +690,6 @@ describe("dashboard backend", () => {
       ]),
     ).toEqual(["EXEC-RUNNING", "SPEC-ACTIVE", "TASK-PLANNED", "TASK-VERIFYING"]);
   });
-
   it("separates canonical reconciliation outcomes from blocked and unresolved work", () => {
     expect(
       reconciliationResult({
@@ -284,27 +736,22 @@ describe("dashboard backend", () => {
       ],
     });
   });
-
   it("requires the local session for projections", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const response = await app.request("/api/v2/operations");
-
     expect(response.status).toBe(401);
   });
-
   it("bootstraps a protected browser session from the dashboard document", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const document = await app.request("/", {
       headers: { "sec-fetch-site": "none" },
     });
     const cookie = document.headers.get("set-cookie");
-
-    expect(cookie).toContain("zaip-dashboard-session=test-session");
+    expect(cookie).toContain("zaip-dashboard-sqlite-session=test-session");
     expect(cookie).toContain("HttpOnly");
     expect(cookie).toContain("SameSite=Strict");
     expect(cookie).toContain("Path=/");
-
-    const response = await app.request("/api/v2/operations", {
+    const response = await app.request("/api/v2/operations?scope=quick", {
       headers: {
         cookie: cookie?.split(";", 1)[0] ?? "",
         "x-zaip-session": "",
@@ -312,19 +759,16 @@ describe("dashboard backend", () => {
     });
     expect(response.status, await response.clone().text()).toBe(200);
   });
-
   it("does not bootstrap sessions for cross-site requests", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
     const response = await app.request("/", {
       headers: { "sec-fetch-site": "cross-site" },
     });
-
     expect(response.headers.get("set-cookie")).toBeNull();
   });
-
   it("keeps origin checks and accepts a valid cookie alongside a stale header", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
-    const cookie = "zaip-dashboard-session=test-session";
+    const cookie = "zaip-dashboard-sqlite-session=test-session";
     const rejectedOrigin = await app.request("/api/v2/pricing", {
       method: "PUT",
       headers: { cookie, origin: "https://example.com" },
@@ -335,237 +779,78 @@ describe("dashboard backend", () => {
     const recoveredSession = await app.request("/api/v2/pricing", {
       headers: { cookie, "x-zaip-session": "stale-session" },
     });
-
     expect(rejectedOrigin.status).toBe(403);
     expect(rejectedHeader.status).toBe(401);
     expect(recoveredSession.status, await recoveredSession.clone().text()).toBe(200);
   });
-
-  it("allowlists authenticated project settings updates and rejects invalid config", async () => {
-    const fixtureRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-project-settings-"));
-    const configPath = join(fixtureRoot, ".agents", "config", "project.yaml");
-    const projectSource = await readFile(
-      join(workspaceRoot, ".agents", "config", "project.yaml"),
-      "utf8",
-    );
-    await mkdir(join(fixtureRoot, ".agents", "config"), { recursive: true });
-    await writeFile(configPath, projectSource, "utf8");
-
-    try {
-      const app = createDashboardApp(fixtureRoot, "test-session");
-      const unauthorized = await app.request("/api/v2/project-settings", { method: "PUT" });
-      const settings = await app.request("/api/v2/project-settings", {
-        headers: { "x-zaip-session": "test-session" },
-      });
-      const payload = (await settings.json()) as {
-        zaip?: { enabled: boolean };
-        project: { id: string };
-        stack: { profile: string; overrides: Record<string, unknown> };
-        tracking: { currency: string };
-      };
-      const updated = await app.request("/api/v2/project-settings", {
-        method: "PUT",
-        headers: {
-          "content-type": "application/json",
-          "x-zaip-session": "test-session",
-        },
-        body: JSON.stringify({
-          ...payload,
-          zaip: { enabled: false },
-          stack: {
-            ...payload.stack,
-            overrides: {
-              ...payload.stack.overrides,
-              languages: {
-                frontend: ["TypeScript"],
-                backend: ["TypeScript"],
-                site: ["Astro"],
-              },
-            },
-          },
-        }),
-      });
-      const invalid = await app.request("/api/v2/project-settings", {
-        method: "PUT",
-        headers: {
-          "content-type": "application/json",
-          "x-zaip-session": "test-session",
-        },
-        body: JSON.stringify({
-          ...payload,
-          tracking: { ...payload.tracking, currency: "real" },
-        }),
-      });
-
-      expect(unauthorized.status).toBe(401);
-      expect(updated.status, await updated.clone().text()).toBe(200);
-      await expect(updated.json()).resolves.toMatchObject({
-        zaip: { enabled: false },
-        stack: {
-          overrides: {
-            languages: {
-              frontend: ["TypeScript"],
-              backend: ["TypeScript"],
-              site: ["Astro"],
-            },
-          },
-        },
-      });
-      expect(invalid.status).toBe(400);
-    } finally {
-      await rm(fixtureRoot, { recursive: true, force: true });
-    }
-  });
-
-  it("serves and atomically updates the central agent catalog with adapter sync", async () => {
-    const fixtureRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-agent-catalog-"));
-    const catalogSource = await readFile(
-      join(workspaceRoot, ".agents", "config", "agents", "catalog.yaml"),
-      "utf8",
-    );
-    const projectSource = await readFile(
-      join(workspaceRoot, ".agents", "config", "project.yaml"),
-      "utf8",
-    );
-    await mkdir(join(fixtureRoot, ".agents", "config", "agents"), { recursive: true });
-    await writeFile(
-      join(fixtureRoot, ".agents", "config", "agents", "catalog.yaml"),
-      catalogSource,
-      "utf8",
-    );
-    await writeFile(join(fixtureRoot, ".agents", "config", "project.yaml"), projectSource, "utf8");
-    let syncCalls = 0;
-
-    try {
-      const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
-        syncAgentAdapters: async () => {
-          syncCalls += 1;
-          return { valid: true, drifted: [] };
-        },
-      });
-      const settings = await app.request("/api/v2/agent-catalog", {
-        headers: { "x-zaip-session": "test-session" },
-      });
-      expect(settings.status, await settings.clone().text()).toBe(200);
-      const payload = (await settings.json()) as {
-        catalog: {
-          agents: Array<{
-            id: string;
-            model: { preferred: string[] };
-            persona: Record<string, unknown>;
-          }>;
-        };
-      };
-      const update = await app.request("/api/v2/agent-catalog", {
-        method: "PUT",
-        headers: {
-          "content-type": "application/json",
-          "x-zaip-session": "test-session",
-        },
-        body: JSON.stringify({
-          agents: payload.catalog.agents.map((agent) =>
-            agent.id === "agent-orchestrator"
-              ? { ...agent, persona: { ...agent.persona, nome: "renata", cargo: "owner" } }
-              : agent,
-          ),
-        }),
-      });
-
-      expect(update.status, await update.clone().text()).toBe(200);
-      await expect(update.json()).resolves.toMatchObject({
-        sync: { required: true, valid: true, drifted: [] },
-      });
-      expect(syncCalls).toBe(1);
-      expect(
-        await readFile(join(fixtureRoot, ".agents", "config", "agents", "catalog.yaml"), "utf8"),
-      ).toContain("renata_owner_zaip_agent");
-    } finally {
-      await rm(fixtureRoot, { recursive: true, force: true });
-    }
-  });
-
-  it("rolls back the agent catalog when adapter synchronization fails", async () => {
-    const fixtureRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-agent-rollback-"));
-    const catalogPath = join(fixtureRoot, ".agents", "config", "agents", "catalog.yaml");
-    const original = await readFile(
-      join(workspaceRoot, ".agents", "config", "agents", "catalog.yaml"),
-      "utf8",
-    );
-    const projectSource = await readFile(
-      join(workspaceRoot, ".agents", "config", "project.yaml"),
-      "utf8",
-    );
-    await mkdir(join(fixtureRoot, ".agents", "config", "agents"), { recursive: true });
-    await writeFile(catalogPath, original, "utf8");
-    await writeFile(join(fixtureRoot, ".agents", "config", "project.yaml"), projectSource, "utf8");
-
-    try {
-      const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
-        syncAgentAdapters: async () => {
-          throw new Error("sync unavailable");
-        },
-      });
-      const settings = await app.request("/api/v2/agent-catalog", {
-        headers: { "x-zaip-session": "test-session" },
-      });
-      const payload = (await settings.json()) as {
-        catalog: {
-          agents: Array<{
-            id: string;
-            model: { preferred: string[] };
-            persona: Record<string, unknown>;
-          }>;
-        };
-      };
-      const response = await app.request("/api/v2/agent-catalog", {
-        method: "PUT",
-        headers: {
-          "content-type": "application/json",
-          "x-zaip-session": "test-session",
-        },
-        body: JSON.stringify({
-          agents: payload.catalog.agents.map((agent) =>
-            agent.id === "agent-orchestrator"
-              ? { ...agent, persona: { ...agent.persona, nome: "renata", cargo: "owner" } }
-              : agent,
-          ),
-        }),
-      });
-
-      expect(response.status).toBe(500);
-      await expect(response.json()).resolves.toMatchObject({
-        error: expect.stringContaining("adapter synchronization failed"),
-      });
-      await expect(readFile(catalogPath, "utf8")).resolves.toBe(original);
-    } finally {
-      await rm(fixtureRoot, { recursive: true, force: true });
-    }
-  });
-
   it("does not serve files outside the configured UI root", async () => {
     const parent = await mkdtemp(join(tmpdir(), "zaip-dashboard-static-boundary-"));
     const uiRoot = join(parent, "ui");
     await mkdir(uiRoot);
     await writeFile(join(uiRoot, "index.html"), "<title>Dashboard</title>", "utf8");
     await writeFile(join(parent, "secret.txt"), "must-not-be-served", "utf8");
-
     try {
       const app = createDashboardApp(workspaceRoot, "test-session", uiRoot);
       const response = await app.request("/..%2Fsecret.txt");
-
       expect(response.status).not.toBe(200);
       await expect(response.text()).resolves.not.toContain("must-not-be-served");
     } finally {
       await rm(parent, { recursive: true, force: true });
     }
   });
-
+  it("proves canonical projection readiness without exposing authenticated data", async () => {
+    const app = createDashboardApp(workspaceRoot, "test-session");
+    const ready = await app.request("/api/v2/ready");
+    const protectedProjection = await app.request("/api/v2/operations?scope=quick");
+    expect(ready.status, await ready.clone().text()).toBe(200);
+    await expect(ready.json()).resolves.toMatchObject({ status: "ready" });
+    expect(protectedProjection.status).toBe(401);
+  });
+  it("uses the SQLite fact for snapshot readiness without lifecycle daily views", async () => {
+    const source = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./server.ts", import.meta.url), "utf8"),
+    );
+    const ready = source.slice(
+      source.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/ready`'),
+      source.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/operations`'),
+    );
+    expect(ready).toContain("if (isSqliteSnapshot)");
+    expect(ready).not.toContain("firstFoldAllTime()");
+    expect(ready).not.toContain("readAggregate(");
+    expect(ready).not.toContain("dashboard_sqlite_prewarm");
+    expect(ready).not.toContain("firstFoldViewportAllTime()");
+    expect(ready).toContain("day_count: metadata.daily_aggregate_count");
+    expect(ready).toContain("storage_mode: metadata.storage_mode");
+  });
+  it("loads daily periods only for the explicit overview/detail projection", async () => {
+    const source = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./server.ts", import.meta.url), "utf8"),
+    );
+    const projection = source.slice(
+      source.indexOf("function buildSqliteOperationsProjection"),
+      source.indexOf("function nullableMetric"),
+    );
+    expect(projection).toContain("options.includePeriods === true ? filesystem.dailyPeriods(filter) : {}");
+    expect(source).toContain("includePeriods: scope === \"detail\" || scope === \"overview\"");
+  });
+  it("rebuilds a fresh aggregate after an in-flight normal read instead of sharing its payload", async () => {
+    const source = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./server.ts", import.meta.url), "utf8"),
+    );
+    const aggregate = source.slice(
+      source.indexOf("const readAggregate"),
+      source.indexOf("const snapshotKey"),
+    );
+    expect(aggregate).toContain("if (!fresh) return pending as Promise<T>;");
+    expect(aggregate).toContain("await pending;");
+    expect(aggregate).toContain("return readAggregate(key, build, true);");
+    expect(aggregate).toContain("aggregatePayloads.set(key, { payload, cachedAt: Date.now() });");
+  });
   it("serves the UI root index for the dashboard root and SPA routes", async () => {
     const parent = await mkdtemp(join(tmpdir(), "zaip-dashboard-static-root-"));
     const uiRoot = join(parent, "ui");
     await mkdir(uiRoot);
     await writeFile(join(uiRoot, "index.html"), "<title>ZAIP Dashboard</title>", "utf8");
-
     try {
       const app = createDashboardApp(workspaceRoot, "test-session", uiRoot);
       for (const path of ["/", "/operations/overview"]) {