@zaip-ai/cli 1.3.8 → 1.4.2

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model.test.ts

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readdir, readFile, rename, utimes, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, readFile, rename, rm, utimes, 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 { createDashboardApp, projectAllTimeTopTasks } from "./server.js";
 import { expectFastCostPagesMatchCanonical } from "./sqlite-cost-fast-page-parity.test-support.js";
 import {
@@ -24,6 +24,8 @@ async function createSqliteTestRoot(): Promise<string> {
   return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
 }
 afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
   await Promise.all(
     roots
       .splice(0)
@@ -33,6 +35,93 @@ afterEach(async () => {
   );
 });
 describe("SQLite dashboard read model", () => {
+  it("materializes a fresh workspace without opening a nonexistent checkpoint database", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
+  });
+
+  it("serves an existing model immediately, refreshes on the SP day boundary and removes deleted sources in place", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+    const task = join(root, ".agents/records/tasks/task.md");
+    await writeFile(task, "# initial\n");
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(new Date("2026-09-05T02:59:00Z"));
+    const first = await rebuildSqliteReadModel(root);
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "generation" });
+    await rm(task);
+    await expect(rebuildSqliteReadModel(root, { preferExisting: true })).resolves.toMatchObject({
+      cache: "stale_seed",
+      files: 2,
+      path: first.path,
+    });
+    const next = await rebuildSqliteReadModel(root);
+    expect(next).toMatchObject({ cache: "rebuilt", files: 1, path: first.path });
+    vi.setSystemTime(new Date("2026-09-05T03:01:00Z"));
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+      cache: "rebuilt",
+      path: first.path,
+    });
+    expect(
+      (await readdir(join(root, ".local/sqlite"))).filter((name) => name.endsWith(".sqlite")),
+    ).toEqual(["zaip-aios-dashboard.sqlite"]);
+    const database = new DatabaseSync(first.path, { readOnly: true });
+    try {
+      expect(
+        database
+          .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='source_fingerprint'")
+          .get(),
+      ).toMatchObject({ value: expect.stringContaining("current_day=2026-09-05") });
+    } finally {
+      database.close();
+    }
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      await expect(filesystem.exists(".agents/records/tasks/task.md")).resolves.toBe(false);
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("rolls back a failed refresh including first-fold payloads while a reader remains open", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    const source = join(root, ".agents/config/project.yaml");
+    await writeFile(source, "zaip:\n  enabled: true\n");
+    const original = await rebuildSqliteReadModel(root);
+    const reader = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await reader.readText(".agents/config/project.yaml")).not.toContain("changed");
+      await writeFile(source, "zaip:\n  enabled: true\nproject:\n  id: changed\n");
+      const exec = DatabaseSync.prototype.exec;
+      const fault = vi.spyOn(DatabaseSync.prototype, "exec").mockImplementation(function (
+        this: DatabaseSync,
+        sql: string,
+      ) {
+        if (sql.trim() === "COMMIT;") throw new Error("injected pre-commit failure");
+        return exec.call(this, sql);
+      });
+      await expect(rebuildSqliteReadModel(root)).rejects.toThrow("injected pre-commit failure");
+      fault.mockRestore();
+      reader.refresh();
+      expect(await reader.readText(".agents/config/project.yaml")).not.toContain("changed");
+      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+        path: original.path,
+        cache: "rebuilt",
+      });
+      reader.refresh();
+      expect(await reader.readText(".agents/config/project.yaml")).toContain("changed");
+    } finally {
+      reader.close();
+    }
+  });
   it("snapshots sorted eligible canonical sources once for fingerprinting and ingestion", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
@@ -59,6 +148,12 @@ describe("SQLite dashboard read model", () => {
     await utimes(included, changedAt, changedAt);
     const after = await sourceFingerprint(root);
     expect(after.fingerprint).not.toBe(before.fingerprint);
+    await writeFile(included, "# replaced\n", "utf8");
+    await utimes(included, changedAt, changedAt);
+    const preservedMetadata = await sourceFingerprint(root);
+    expect(preservedMetadata.candidates.at(-1)?.size).toBe(after.candidates.at(-1)?.size);
+    expect(preservedMetadata.candidates.at(-1)?.mtimeMs).toBe(after.candidates.at(-1)?.mtimeMs);
+    expect(preservedMetadata.fingerprint).not.toBe(after.fingerprint);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ files: 2 });
   });
 
@@ -87,7 +182,7 @@ describe("SQLite dashboard read model", () => {
       ".agents/records/lifecycle/views/foreign.json",
     );
   });
-  it("uses a current-schema seed after a canonical change", async () => {
+  it("rebuilds the persistent database after a canonical change", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     const task = join(root, ".agents", "records", "tasks", "task.md");
@@ -101,25 +196,11 @@ describe("SQLite dashboard read model", () => {
     await writeFile(task, "# original\n", "utf8");
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
     await writeFile(task, "# changed canonically\n", "utf8");
-    const previousPath = process.env.ZAIP_SQLITE_DB_PATH;
-    const previousSeed = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
-    try {
-      process.env.ZAIP_SQLITE_DB_PATH = join(root, ".local", "dashboard-sqlite", "next.sqlite");
-      process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
-      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
-        cache: "stale_seed",
-        files: 2,
-      });
-      await expect(rebuildSqliteReadModel(root, { forceCanonical: true })).resolves.toMatchObject({
-        cache: "rebuilt",
-        files: 2,
-      });
-    } finally {
-      if (previousPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
-      else process.env.ZAIP_SQLITE_DB_PATH = previousPath;
-      if (previousSeed === undefined) delete process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
-      else process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = previousSeed;
-    }
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+      cache: "rebuilt",
+      files: 2,
+      path: join(root, ".local", "sqlite", "zaip-aios-dashboard.sqlite"),
+    });
   });
 
   it("keeps an exact cached range valid with future facts and fast-paths an empty later month", async () => {
@@ -133,7 +214,7 @@ describe("SQLite dashboard read model", () => {
       "utf8",
     );
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
-    const path = join(root, ".local", "dashboard-sqlite", "read-model.sqlite");
+    const path = join(root, ".local", "sqlite", "zaip-aios-dashboard.sqlite");
     const database = new DatabaseSync(path);
     database
       .prepare(
@@ -199,7 +280,7 @@ describe("SQLite dashboard read model", () => {
     }
   });
 
-  it("does not serve a prior-schema seed during the one-time SQLite cache migration", async () => {
+  it("uses only the official persistent path after a rebuild", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     await mkdir(join(root, ".agents", "records", "tasks"), { recursive: true });
@@ -210,33 +291,20 @@ describe("SQLite dashboard read model", () => {
       "utf8",
     );
     await writeFile(join(root, ".agents", "records", "tasks", "task.md"), "# task\n", "utf8");
-    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
-    const cacheDirectory = join(root, ".local", "dashboard-sqlite", "cache");
-    const current = (await readdir(cacheDirectory)).find(
-      (entry) => /^v\d+-/.test(entry) && entry.endsWith(".sqlite"),
-    );
-    expect(current).toBeDefined();
-    const legacy = join(cacheDirectory, current!.replace(/^v\d+-/, ""));
-    await rename(join(cacheDirectory, current!), legacy);
-    const oldSeed = new DatabaseSync(legacy);
-    oldSeed
-      .prepare(
-        "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', '65') WHERE payload_type='metadata' AND json_extract(payload_json, '$.key')='schema_version'",
-      )
-      .run();
-    oldSeed.close();
-    const priorPath = process.env.ZAIP_SQLITE_DB_PATH;
-    const priorSeed = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
-    try {
-      process.env.ZAIP_SQLITE_DB_PATH = join(root, ".local", "dashboard-sqlite", "migrated.sqlite");
-      process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
-      await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });
-    } finally {
-      if (priorPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
-      else process.env.ZAIP_SQLITE_DB_PATH = priorPath;
-      if (priorSeed === undefined) delete process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
-      else process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = priorSeed;
-    }
+    const result = await rebuildSqliteReadModel(root);
+    expect(result.path).toBe(join(root, ".local", "sqlite", "zaip-aios-dashboard.sqlite"));
+    expect(await readdir(join(root, ".local", "sqlite"))).toEqual(
+      expect.arrayContaining(["zaip-aios-dashboard.sqlite"]),
+    );
+    expect(
+      (await readdir(join(root, ".local", "sqlite"))).every((name) =>
+        [
+          "zaip-aios-dashboard.sqlite",
+          "zaip-aios-dashboard.sqlite-shm",
+          "zaip-aios-dashboard.sqlite-wal",
+        ].includes(name),
+      ),
+    ).toBe(true);
   });
 
   it("rateia sobreposição e virada de dia na fato temporal aditiva", () => {
@@ -797,7 +865,7 @@ created_at: 2026-08-10T11:01:00.000Z
       "utf8",
     );
     await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     expect(
@@ -1176,7 +1244,7 @@ created_at: 2026-08-10T11:01:00.000Z
     );
 
     await rebuildSqliteReadModel(root);
-    const snapshot = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const snapshot = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     try {
@@ -1184,7 +1252,7 @@ created_at: 2026-08-10T11:01:00.000Z
         snapshot
           .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
           .get(),
-      ).toEqual({ value: "71" });
+      ).toEqual({ value: "73" });
     } finally {
       snapshot.close();
     }
@@ -1671,11 +1739,15 @@ created_at: 2026-08-10T11:01:00.000Z
       "utf8",
     );
     await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     expect(
-      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
+      database
+        .prepare(
+          "SELECT duration_ms, duration_provenance FROM zaip_aios_activities WHERE payload_type IS NULL",
+        )
+        .get(),
     ).toEqual({ duration_ms: 1_800_000, duration_provenance: "attributed_token_active" });
     database.close();
   });
@@ -1776,7 +1848,7 @@ created_at: 2026-08-10T11:01:00.000Z
       "utf8",
     );
     await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     expect(
@@ -1971,7 +2043,7 @@ created_at: 2026-08-10T11:01:00.000Z
       `${[historicalStarted, ...historicalRecords.slice(1)].map((record) => JSON.stringify(record)).join("\n")}\n`,
     );
     await rebuildSqliteReadModel(root);
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     expect(
@@ -3276,7 +3348,7 @@ created_at: 2026-08-10T11:01:00.000Z
       cost_brl: null,
       execution_day_count: 0,
     });
-    const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
       readOnly: true,
     });
     const columns = (table: string) =>