@zaip-ai/cli 2.6.0 → 3.0.0

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

@@ -1,11 +1,44 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { type SqliteReadModelFileSystem, sqliteReadModelPath } from "./sqlite-read-model.js";
 import {
-  type SqliteReadModelFileSystem,
-  sqliteReadModelPath,
-  validateSqliteReadModelSchema,
-} from "./sqlite-read-model.js";
+  readModelSchemaVersion,
+  requiredIndexes,
+  requiredPersistedTables,
+  requiredViews,
+} from "./sqlite-read-model-schema.js";
+
+/** The worker validates integrity and schema before emitting this receipt. */
+export function validateSnapshotWorkerReceipt(stdout: string, destination: string): void {
+  const result = JSON.parse(stdout) as {
+    storage_mode?: unknown;
+    path?: unknown;
+    schema?: {
+      schemaVersion?: unknown;
+      tableCount?: unknown;
+      viewCount?: unknown;
+      indexCount?: unknown;
+    };
+  } | null;
+  const schema = result?.schema;
+  if (
+    result?.storage_mode !== "sqlite_read_model" ||
+    typeof result.path !== "string" ||
+    resolve(result.path) !== resolve(destination) ||
+    schema?.schemaVersion !== readModelSchemaVersion ||
+    schema.tableCount !== requiredPersistedTables.length ||
+    typeof schema.viewCount !== "number" ||
+    !Number.isSafeInteger(schema.viewCount) ||
+    schema.viewCount < requiredViews.length ||
+    typeof schema.indexCount !== "number" ||
+    !Number.isSafeInteger(schema.indexCount) ||
+    schema.indexCount < requiredIndexes.length
+  )
+    throw new Error(
+      "SQLite refresh worker did not return a valid schema receipt for this destination",
+    );
+}
 
 async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destination: string) {
   const scriptCandidates = [
@@ -24,6 +57,8 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
     throw new Error("SQLite refresh worker script is unavailable from this runtime checkout");
   await new Promise<void>((resolveWorker, rejectWorker) => {
     let stderr = "";
+    let stdout = "";
+    let oversizedReceipt = false;
     const worker = spawn(process.execPath, [script], {
       cwd: workspaceRoot,
       env: {
@@ -33,13 +68,18 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
         ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "0",
         ZAIP_DASHBOARD_LAUNCH_PROGRESS: "0",
       },
-      stdio: ["ignore", "ignore", "pipe"],
+      stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
     // Lease shutdown may end the serving parent while a slow snapshot rebuild
     // is still writing. Terminate the direct child synchronously during parent
     // exit so the next launcher cannot overlap the persistent SQLite writer.
     const cleanupWorker = attachRefreshWorkerCleanup(worker);
+    worker.stdout?.setEncoding("utf8");
+    worker.stdout?.on("data", (chunk: string) => {
+      if (stdout.length + chunk.length > 64_000) oversizedReceipt = true;
+      if (!oversizedReceipt) stdout += chunk;
+    });
     worker.stderr?.setEncoding("utf8");
     worker.stderr?.on("data", (chunk: string) => {
       stderr = `${stderr}${chunk}`.slice(-8_000);
@@ -48,13 +88,22 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
       cleanupWorker();
       rejectWorker(error);
     });
-    worker.once("exit", (code) => {
+    // close follows stdout drain; exit alone may precede the receipt bytes.
+    worker.once("close", (code) => {
       cleanupWorker();
-      return code === 0
-        ? resolveWorker()
-        : rejectWorker(
-            new Error(`SQLite refresh worker failed (${code}): ${stderr.trim() || "no stderr"}`),
-          );
+      if (code !== 0) {
+        rejectWorker(
+          new Error(`SQLite refresh worker failed (${code}): ${stderr.trim() || "no stderr"}`),
+        );
+        return;
+      }
+      try {
+        if (oversizedReceipt) throw new Error("SQLite refresh worker receipt exceeds size limit");
+        validateSnapshotWorkerReceipt(stdout, destination);
+        resolveWorker();
+      } catch (error) {
+        rejectWorker(error);
+      }
     });
   });
 }
@@ -88,6 +137,7 @@ export async function refreshSqliteSnapshotInWorker(
 ) {
   const destination = sqliteReadModelPath(workspaceRoot);
   await rebuildPersistentDatabaseInWorker(workspaceRoot, destination);
-  validateSqliteReadModelSchema(destination);
+  // Integrity/schema checking belongs to the worker, not the HTTP event loop.
+  // Zero exit alone is insufficient: its exact-destination receipt is mandatory.
   filesystem.refresh();
 }

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

@@ -19,6 +19,32 @@ afterEach(() => {
 });
 
 describe("snapshot source synchronization", () => {
+  it("reports capture failure separately while refreshing canonical data", async () => {
+    vi.useFakeTimers();
+    const error = new Error("capture timed out");
+    const onCaptureFailure = vi.fn();
+    const onRefreshFailure = vi.fn();
+    const onCaptureSuccess = vi.fn();
+    const capture = vi.fn().mockRejectedValueOnce(error).mockResolvedValue(undefined);
+    const refresh = vi.fn(async () => undefined);
+    startSnapshotSynchronization({
+      workspaceRoot: "C:/workspace",
+      staleSeed: false,
+      watchSources: true,
+      refresh,
+      captureActiveTelemetry: capture,
+      onCaptureFailure,
+      onCaptureSuccess,
+      onRefreshFailure,
+    });
+    await vi.advanceTimersByTimeAsync(301);
+    expect(onCaptureFailure).toHaveBeenCalledWith(error);
+    expect(onRefreshFailure).not.toHaveBeenCalled();
+    expect(refresh).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(onCaptureSuccess).toHaveBeenCalledTimes(1);
+    expect(refresh).toHaveBeenCalledTimes(2);
+  });
   it("watches current data for both creation and alteration refreshes", async () => {
     vi.useFakeTimers();
     const refresh = vi.fn(async () => undefined);

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

@@ -8,6 +8,8 @@ export function startSnapshotSynchronization(input: {
   refresh: () => Promise<void>;
   /** Exact active-Codex collection, separate from projection and lifecycle repair. */
   captureActiveTelemetry?: () => Promise<void>;
+  onCaptureFailure?: (error: unknown) => void;
+  onCaptureSuccess?: () => void;
   /** Report failed asynchronous refreshes; a stale snapshot must never look healthy. */
   onRefreshFailure?: (input: { trigger: "stale_seed" | "source_change"; error: unknown }) => void;
 }): void {
@@ -40,7 +42,8 @@ export function startSnapshotSynchronization(input: {
     if (input.captureActiveTelemetry === undefined) return scheduleRefresh();
     void input
       .captureActiveTelemetry()
-      .catch((error: unknown) => input.onRefreshFailure?.({ trigger: "source_change", error }))
+      .then(() => input.onCaptureSuccess?.())
+      .catch((error: unknown) => input.onCaptureFailure?.(error))
       .finally(scheduleRefresh);
   };
   // Run at most once a minute. File watchers only project canonical changes;

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

@@ -0,0 +1,97 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createV2WorkspaceLayout } from "@zaip-ai/core";
+import { afterEach, expect, it, vi } from "vitest";
+import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+const readers: SqliteReadModelFileSystem[] = [];
+afterEach(async () => {
+  vi.restoreAllMocks();
+  for (const reader of readers.splice(0)) reader.close();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+const taskId = "TASK-2026-09-10-12-00-TRACE-AAAA";
+const layout = createV2WorkspaceLayout(
+  {
+    schema_version: 1,
+    project: { id: "trace", name: "Trace", timezone: "America/Sao_Paulo" },
+    stack: { id: "zaip-aios-stack", overrides: {} },
+    clients: { codex: true, claude: false },
+    tracking: { enabled: true, currency: "BRL", storage_mode: "tracked_sanitized" },
+  },
+  {
+    lock_version: 2,
+    framework: { version: "3.0.0", distribution_sha256: null },
+    layout: { version: 3 },
+    resolved_profile: { id: null, sha256: null },
+    managed_files: {},
+  },
+);
+const taskContent = (id: string, title: string) =>
+  `---\nid: ${id}\ntitle: ${title}\nstatus: completed\nrisk: standard\ncreated_at: 2026-09-10T15:00:00.000Z\n---\n# ${title}\n`;
+async function fixture(files: Record<string, string>) {
+  const root = await mkdtemp(join(tmpdir(), "zaip-trace-bounded-"));
+  roots.push(root);
+  await prepareMultiProviderFixture(root);
+  for (const [path, content] of Object.entries(files)) {
+    const target = join(root, path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, content);
+  }
+  await rebuildSqliteReadModel(root);
+  const filesystem = new SqliteReadModelFileSystem(root);
+  readers.push(filesystem);
+  return filesystem;
+}
+
+it("resolves the exact Task and filters oversized history before transport without losing documents", async () => {
+  const path = layout.activePath("task", taskId);
+  const small = ".agents/records/changes/trace/artifacts/tests/notes.md";
+  const large = ".agents/records/changes/trace/artifacts/tests/oversized.md";
+  const astral = ".agents/records/changes/trace/artifacts/tests/astral.md";
+  const shadowId = "TASK-2026-09-10-11-00-SHADOW-AAAA";
+  const filesystem = await fixture({
+    [path]: taskContent(taskId, "Requested Task"),
+    [layout.activePath("task", shadowId)]: taskContent(shadowId, `References ${taskId}`),
+    [small]: `# ${taskId}\n${"x".repeat(250_000 - taskId.length - 3)}`,
+    [large]: `${taskId}\n${"x".repeat(250_001)}`,
+    [astral]: `${taskId}\n${"😀".repeat(130_000)}`,
+  });
+  const expected = filesystem
+    .canonicalTraceFiles([taskId])
+    .filter((row) => row.content.length <= 250_000)
+    .map((row) => row.path);
+  expect(expected).toContain(small);
+  expect(expected).not.toContain(large);
+  expect(expected).not.toContain(astral);
+  const scan = vi.spyOn(filesystem, "canonicalTraceFiles");
+  const trace = await buildSqliteTaskTrace(filesystem, layout, taskId);
+  expect(trace.task_title).toBe("Requested Task");
+  expect(trace.task_id).toBe(taskId);
+  expect(trace.documents.map((row) => row.path)).toEqual(expected);
+  expect(scan).toHaveBeenCalledOnce();
+  expect(scan.mock.calls[0]?.[1]).toBe(250_000);
+  expect(scan.mock.results[0]?.value.map((row: { path: string }) => row.path)).not.toContain(large);
+});
+
+it("rejects a mismatched Task identity instead of tracing a document that mentions it", async () => {
+  const filesystem = await fixture({
+    [layout.activePath("task", taskId)]: taskContent("TASK-2026-09-10-11-00-WRONG-AAAA", taskId),
+  });
+  await expect(buildSqliteTaskTrace(filesystem, layout, taskId)).rejects.toThrow(
+    /identity mismatch/,
+  );
+});
+
+it("retains the canonical divergent-layout guard and rejects invalid bounds", async () => {
+  const filesystem = await fixture({
+    [layout.activePath("task", taskId)]: taskContent(taskId, "Active"),
+    [`.agents/data/tasks/2026/09/10/${taskId}.md`]: taskContent(taskId, "Divergent"),
+  });
+  await expect(buildSqliteTaskTrace(filesystem, layout, taskId)).rejects.toThrow(/Divergent/);
+  expect(() => filesystem.canonicalTraceFiles([taskId], -1)).toThrow(/Invalid trace content bound/);
+});

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import type { WorkspaceLayout } from "@zaip-ai/core";
+import { resolveArtifactReadPath, type WorkspaceLayout } from "@zaip-ai/core";
 import type { TaskTrace, TraceDocument } from "@zaip-ai/dashboard-traceability/contracts";
 import {
   buildTraceStageRecords,
@@ -8,26 +8,23 @@ import {
 } from "@zaip-ai/dashboard-traceability/server";
 import type { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 
-export function buildSqliteTaskTrace(
+export async function buildSqliteTaskTrace(
   filesystem: SqliteReadModelFileSystem,
   layout: WorkspaceLayout,
   taskId: string,
-): TaskTrace {
-  const initial = filesystem.canonicalTraceFiles([taskId]);
-  const taskFile = initial.find(
-    (row) =>
-      row.path.includes("/.agents/data/tasks/") ||
-      row.path.includes(".agents/data/tasks/") ||
-      row.path.includes("/.agents/records/tasks/") ||
-      row.path.includes(".agents/records/tasks/"),
-  );
-  if (taskFile === undefined) throw new Error(`Canonical Task ${taskId} was not found`);
+): Promise<TaskTrace> {
+  // Resolve the exact canonical identity, not the first Task mentioning it.
+  // This also avoids scanning all historical contents just to locate one Task.
+  const taskPath = await resolveArtifactReadPath(filesystem, layout, "task", taskId);
+  if (taskPath === null) throw new Error(`Canonical Task ${taskId} was not found`);
+  const taskFile = { path: taskPath, content: await filesystem.readText(taskPath) };
   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, "");
   };
+  if (scalar("id") !== taskId) throw new Error(`Canonical Task identity mismatch: ${taskId}`);
   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;
@@ -37,7 +34,7 @@ export function buildSqliteTaskTrace(
     (value): value is string => value !== null,
   );
   const documents = filesystem
-    .canonicalTraceFiles(markers)
+    .canonicalTraceFiles(markers, 250_000)
     .filter(
       (row) => /\.(?:md|json|jsonl|txt|log)$/i.test(row.path) && row.content.length <= 250_000,
     )

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

@@ -10,15 +10,7 @@ import type { DashboardRouteContext } from "./server-route-context.js";
 import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
 import { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 export function registerTraceRoutes(app: Hono, dependencies: DashboardRouteContext) {
-  const {
-    filesystem,
-    canonicalFilesystem,
-    isSqliteSnapshot,
-    readLayout,
-    readSnapshot,
-    readAggregate,
-    clearSnapshotCache,
-  } = dependencies;
+  const { filesystem, readLayout } = dependencies;
   app.on(["GET", "HEAD"], `${API_PREFIX}/tasks/:id`, async (context) => {
     try {
       const layout = await readLayout();
@@ -53,7 +45,7 @@ export function registerTraceRoutes(app: Hono, dependencies: DashboardRouteConte
       return headOrJson(
         context,
         filesystem instanceof SqliteReadModelFileSystem
-          ? buildSqliteTaskTrace(filesystem, layout, taskId)
+          ? await buildSqliteTaskTrace(filesystem, layout, taskId)
           : await buildTaskTrace(filesystem, layout, taskId),
       );
     } catch (error) {

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

@@ -0,0 +1,84 @@
+import { serializeMarkdown, WorkspaceFileSystem } from "@zaip-ai/core";
+import { expect, it } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { withSqliteReadModelFixture } from "./server.test-fixtures.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+it("indexes draft and terminal Tasks in SQLite without adding drafts to Kanban", async () => {
+  await withSqliteReadModelFixture("trace-index", async ({ root }) => {
+    const at = "2026-09-11T10:00:00.000Z";
+    const canonical = new WorkspaceFileSystem(root);
+    for (const [i, status] of ["draft", "cancelled", "blocked"].entries()) {
+      await canonical.writeTextAtomic(
+        `.agents/records/tasks/2026/09/task-${i}.md`,
+        serializeMarkdown({
+          metadata: {
+            schema_version: 2,
+            id: `TASK-INDEX-${i}`,
+            title: `Task ${status}`,
+            status,
+            revision: 1,
+            change_id: `CHG-INDEX-${i}`,
+            short_name: `index-${i}`,
+            objective: "Identity fixture",
+            risk: "standard",
+            priority: "medium",
+            owner: null,
+            requirement_ids: ["REQ-WORK-001"],
+            acceptance_ids: ["AC-WORK-001-09"],
+            depends_on: [],
+            write_scopes: ["proof"],
+            plan_revision: null,
+            plan_hash: null,
+            created_at: at,
+            updated_at: at,
+            started_at: null,
+            finished_at: null,
+            result: null,
+          },
+          body: "# Identity fixture\n",
+        }),
+      );
+    }
+    await rebuildSqliteReadModel(root);
+    const sqlite = new SqliteReadModelFileSystem(root);
+    try {
+      const app = createDashboardApp(root, "fixture", undefined, { filesystem: sqlite });
+      const request = async (query: string) => {
+        const response = await app.request(`/api/v2/operations?${query}`, {
+          headers: { "x-zaip-session": "fixture" },
+        });
+        expect(response.status).toBe(200);
+        return response.json() as Promise<{
+          total: number;
+          tasks: { id: string; status: string }[];
+        }>;
+      };
+      const first = await request("scope=traceability&offset=0&limit=2");
+      const second = await request("scope=traceability&offset=2&limit=2");
+      expect(first.total).toBe(3);
+      expect(first.tasks).toHaveLength(2);
+      expect(second.tasks).toHaveLength(1);
+      expect([...first.tasks, ...second.tasks].map((task) => task.id)).toEqual([
+        "TASK-INDEX-2",
+        "TASK-INDEX-1",
+        "TASK-INDEX-0",
+      ]);
+      expect(second.tasks[0]?.status).toBe("draft");
+      for (const stage of [
+        "definition",
+        "planning",
+        "ready",
+        "executing",
+        "completed",
+        "blocked",
+      ]) {
+        const board = await request(`scope=board&stage=${stage}&kind=all-tasks`);
+        expect(board.tasks.map((task: { id: string }) => task.id)).not.toContain("TASK-INDEX-0");
+      }
+      expect((await request("scope=traceability&offset=3&limit=2")).tasks).toEqual([]);
+    } finally {
+      sqlite.close();
+    }
+  });
+});

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

@@ -212,6 +212,7 @@ export function createDashboardApp(
   };
   let observedSnapshotRevision: string | null = null;
   const projectionRefreshDiagnostics = createProjectionRefreshDiagnostics();
+  let activeCaptureFailure: { code: string; occurred_at: string; cause: string } | null = null;
   let projectionRefreshInFlight: Promise<void> | null = null;
   let projectionRefreshRequested = false;
   const rebuildProjection = async () => {
@@ -262,6 +263,16 @@ export function createDashboardApp(
       ? { captureActiveTelemetry: () => captureActiveCodexTelemetry(workspaceRoot) }
       : {}),
     onRefreshFailure: projectionRefreshDiagnostics.record,
+    onCaptureSuccess: () => {
+      activeCaptureFailure = null;
+    },
+    onCaptureFailure: (error) => {
+      activeCaptureFailure = {
+        code: "active_telemetry_capture_failed",
+        occurred_at: new Date().toISOString(),
+        cause: error instanceof Error ? error.name : "unknown_error",
+      };
+    },
   });
   const reconcileWork = createWorkReconciliation({
     reconcile: (mode) =>
@@ -397,13 +408,15 @@ export function createDashboardApp(
         kind: RUNTIME_KIND,
         workspaceKey,
         service: "zaip-aios-dashboard",
-        status: projectionRefreshDiagnostics.healthStatus,
+        status:
+          activeCaptureFailure === null ? projectionRefreshDiagnostics.healthStatus : "degraded",
         api_version: 2,
         workspace_layout: layout.version,
         read_only: true,
         storage: isSqliteSnapshot ? filesystem.metadata() : { storage_mode: "filesystem" },
         snapshot_state: snapshotState,
         projection_refresh_failure: projectionRefreshDiagnostics.failure,
+        active_capture_failure: activeCaptureFailure,
       });
     } catch (error) {
       return headOrJson(
@@ -450,6 +463,7 @@ export function createDashboardApp(
           day_count: metadata.daily_aggregate_count,
           snapshot_state: snapshotState,
           projection_refresh_failure: projectionRefreshDiagnostics.failure,
+          active_capture_failure: activeCaptureFailure,
           snapshot_revision: revision,
         });
       }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-dimension-facts.test.ts

@@ -258,8 +258,19 @@ describe("cost invocation dimension rebuild", () => {
     expect(factRows(database, "cost_invocation_dimension_facts")).toEqual(
       factRows(database, "legacy_cost_invocation_dimension_facts"),
     );
+    // SQLite versions bundled with supported Node runtimes may serialize REALs
+    // with different precision. The contract is exact legacy JSON parity on
+    // that engine, not a hard-coded decimal spelling from SQLite 3.49.
+    const expectedCosts = database
+      .prepare(`
+        SELECT json_extract(payload, '$.cost_usd') AS cost_usd,
+          json_extract(payload, '$.cost_brl') AS cost_brl
+        FROM (SELECT json_object('cost_usd', ?, 'cost_brl', ?) AS payload)
+      `)
+      .get(0.1 + 0.2, 1234567.8912345679);
+    expect(expectedCosts).toEqual({ cost_usd: expect.any(Number), cost_brl: expect.any(Number) });
     expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
-      expect.objectContaining({ residual: 0, cost_usd: 0.3, cost_brl: 1234567.89123457 }),
+      expect.objectContaining({ residual: 0, ...expectedCosts }),
     );
   });
 

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-file-index.test.ts

@@ -0,0 +1,69 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { rebuildSqliteReadModel, validateSqliteReadModelSchema } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+it("indexes exact and LIKE file lookups without changing case or prefix membership", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-file-index-"));
+  let database: DatabaseSync | undefined;
+  try {
+    await prepareMultiProviderFixture(root);
+    await rebuildSqliteReadModel(root);
+    const path = join(root, ".local/sqlite/zaip-aios-dashboard.sqlite");
+    database = new DatabaseSync(path);
+    const reader = database;
+    const queries = [
+      {
+        sql: "SELECT path, content FROM zaip_vw_files WHERE path = ?",
+        arg: ".agents/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".AGENTS/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path LIKE ? ORDER BY path",
+        arg: ".agents/missing/%",
+        index: "zaip_activities_file_path",
+      },
+      {
+        sql: "SELECT path FROM zaip_vw_files WHERE path = ?",
+        arg: ".AGENTS/config/project.yaml",
+        index: "zaip_activities_file_path",
+      },
+    ];
+    const indexed = queries.map(({ sql, arg, index }) => {
+      const plan = reader.prepare(`EXPLAIN QUERY PLAN ${sql}`).all(arg);
+      expect(JSON.stringify(plan)).toContain(`USING INDEX ${index}`);
+      return reader.prepare(sql).all(arg);
+    });
+    expect(indexed[0]).toHaveLength(1);
+    expect(indexed[1]?.length).toBeGreaterThan(1);
+    expect(indexed[2]).toEqual(indexed[1]);
+    expect(indexed[3]).toEqual([]);
+    expect(indexed[4]).toEqual([]);
+    const view = database
+      .prepare("SELECT sql FROM sqlite_master WHERE name='zaip_vw_files'")
+      .get() as { sql: string };
+    database.exec("DROP VIEW zaip_vw_files;");
+    database.exec(view.sql.replace(" INDEXED BY zaip_activities_file_path", ""));
+    database.exec("DROP INDEX zaip_activities_file_path;");
+    expect(() => validateSqliteReadModelSchema(path)).toThrow(/missing required indexes/);
+    for (const [position, { sql, arg }] of queries.entries()) {
+      expect(database.prepare(sql).all(arg)).toEqual(indexed[position]);
+    }
+  } finally {
+    database?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

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

@@ -231,7 +231,9 @@ export function readFirstFoldViewport(
       SELECT COALESCE(status, 'draft') AS status, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(status, 'draft'))
   ), task_risk AS (
     SELECT json_group_object(risk, task_count) AS task_risk_json FROM (
-      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items WHERE entity_kind='task' GROUP BY COALESCE(risk, 'standard'))
+      SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count FROM items
+      WHERE entity_kind='task' AND COALESCE(status, 'draft') <> 'draft'
+      GROUP BY COALESCE(risk, 'standard'))
   )
   SELECT totals.*, run_totals.*, duration_totals.*, bounds.*, item_totals.*, task_status.*, task_risk.*
     FROM totals CROSS JOIN run_totals CROSS JOIN duration_totals CROSS JOIN bounds

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-force-canonical.test.ts

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
 
 const roots: string[] = [];
@@ -17,12 +17,14 @@ async function fixture(): Promise<string> {
 }
 
 afterEach(async () => {
+  vi.restoreAllMocks();
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
 describe("forceCanonical SQLite refresh", () => {
   it("bypasses a healthy generation and verifies canonical sources again", async () => {
     const root = await fixture();
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const initial = await rebuildSqliteReadModel(root);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
       cache: "generation",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-refresh.test.ts

@@ -173,6 +173,8 @@ describe("incremental refresh preserves historical facts", () => {
   it("updates and removes changed sources in place with full-build query parity and untouched historical payloads", async () => {
     const root = await fixture();
     const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    // This scenario exercises settled historical checkpoints, not rapid writes.
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const first = await rebuildSqliteReadModel(root);
     const history = inspect(first.path, historySql);
     expect(history).toHaveLength(2);