@zaip-ai/cli 1.3.7 → 1.4.1

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

@@ -0,0 +1,251 @@
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import * as decisions from "../../../../../packages/decisions/src/index.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+async function fixture() {
+  const directory = resolve(import.meta.dirname, "../../../../..", ".local/sqlite/tests");
+  await mkdir(directory, { recursive: true });
+  const root = await mkdtemp(join(directory, "incremental-"));
+  roots.push(root);
+  return root;
+}
+function inspect(path: string, sql: string) {
+  const database = new DatabaseSync(path, { readOnly: true });
+  try {
+    return database.prepare(sql).all();
+  } finally {
+    database.close();
+  }
+}
+const historySql = `SELECT activity_row_id, activity_key, payload_json FROM zaip_aios_activities
+  WHERE activity_key IN ('file:.agents/records/runs/2026/08/RUN-UNASSISTED.jsonl',
+    'source_state:.agents/records/runs/2026/08/RUN-UNASSISTED.jsonl') ORDER BY activity_key`;
+
+async function expectFullParity(root: string) {
+  const baseline = await fixture();
+  await cp(join(root, ".agents"), join(baseline, ".agents"), { recursive: true });
+  const baselineBuild = await rebuildSqliteReadModel(baseline, { forceCanonical: true });
+  const incremental = new SqliteReadModelFileSystem(root);
+  const complete = new SqliteReadModelFileSystem(baseline);
+  try {
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_models",
+      "cost_monitor_providers",
+      "cost_monitor_tasks",
+      "cost_monitor_specs",
+      "cost_monitor_prds",
+      "operations_work_list",
+    ] as const) {
+      expect(incremental.viewPage(view, { limit: 100 }), view).toEqual(
+        complete.viewPage(view, { limit: 100 }),
+      );
+    }
+    const databasePath = join(root, ".local/sqlite/zaip-aios-dashboard.sqlite");
+    expect(
+      inspect(databasePath, "SELECT * FROM developer_cost_projection ORDER BY account_id"),
+    ).toEqual(
+      inspect(baselineBuild.path, "SELECT * FROM developer_cost_projection ORDER BY account_id"),
+    );
+    const facts =
+      "SELECT run_id,root_run_id,parent_run_id,activity_key,work_item_kind,title,work_item_status,work_stage,risk,duration_ms,cost_usd,cost_brl,total_tokens FROM zaip_aios_activities WHERE payload_type IS NULL OR payload_type='shared_creation_allocation' ORDER BY activity_key";
+    expect(inspect(databasePath, facts)).toEqual(inspect(baselineBuild.path, facts));
+  } finally {
+    incremental.close();
+    complete.close();
+  }
+}
+
+afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("incremental refresh preserves historical facts", () => {
+  it("refreshes developer delivery and shared SPEC allocation from cached Run facts", async () => {
+    const root = await fixture();
+    await prepareMultiProviderFixture(root);
+    const runPath = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const records = (await readFile(runPath, "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+    records[0].developer_identity = {
+      schema_version: 1,
+      provider: "github",
+      account_id: "42",
+      login_snapshot: "dev-fixture",
+      verified_at: "2026-08-04T12:00:00.000Z",
+      attribution_source: "verified_local_account",
+    };
+    await writeFile(runPath, records.map((row) => JSON.stringify(row)).join("\n") + "\n");
+    await rebuildSqliteReadModel(root);
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await mkdir(join(root, ".agents/records/specs"), { recursive: true });
+    const task = join(root, ".agents/records/tasks/TASK-MULTI.md");
+    const spec = (id: string) =>
+      `---\nid: ${id}\ntitle: ${id}\nstatus: completed\ncreation_run_id: RUN-MULTI\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n`;
+    await writeFile(
+      task,
+      "---\nid: TASK-MULTI\ntitle: Delivered task\nstatus: completed\ncompleted_run_id: RUN-MULTI\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n",
+    );
+    const a = join(root, ".agents/records/specs/SPEC-A.md");
+    const b = join(root, ".agents/records/specs/SPEC-B.md");
+    await writeFile(a, spec("SPEC-A"));
+    const spy = vi.spyOn(decisions, "foldRunV2Records");
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+    spy.mockClear();
+    await writeFile(b, spec("SPEC-B"));
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+    spy.mockClear();
+    await rm(a);
+    await rm(task);
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+  }, 120_000);
+
+  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);
+    const first = await rebuildSqliteReadModel(root);
+    const history = inspect(first.path, historySql);
+    expect(history).toHaveLength(2);
+    const schema = inspect(first.path, "PRAGMA schema_version");
+    const fold = vi.spyOn(decisions, "foldRunV2Records");
+    const exec = DatabaseSync.prototype.exec;
+    vi.spyOn(DatabaseSync.prototype, "exec").mockImplementation(function (
+      this: DatabaseSync,
+      sql: string,
+    ) {
+      const result = exec.call(this, sql);
+      if (
+        sql.includes("BEGIN IMMEDIATE") &&
+        this.prepare("SELECT 1 FROM sqlite_master WHERE name='zaip_aios_activities'").get()
+      ) {
+        // A historical activity outside the changed interval must not be
+        // deleted/reinserted or updated just because a different source changed.
+        for (const action of ["DELETE", "UPDATE"])
+          exec.call(
+            this,
+            `
+          CREATE TEMP TRIGGER protect_history_${action} BEFORE ${action} ON main.zaip_aios_activities
+          WHEN OLD.payload_type IS NULL AND OLD.run_id='RUN-UNAVAILABLE'
+          BEGIN SELECT RAISE(ABORT, 'unaffected historical activity was rewritten'); END;
+        `,
+          );
+      }
+      return result;
+    });
+    const unchanged = await rebuildSqliteReadModel(root);
+    expect(unchanged).toMatchObject({
+      cache: "generation",
+      refresh: { processed_sources: 0, canonical_runs_refolded: 0 },
+    });
+    expect(fold.mock.calls.length).toBe(0);
+    const task = join(root, ".agents/records/tasks/TASK-MULTI.md");
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await writeFile(
+      task,
+      "---\nid: TASK-MULTI\ntitle: Incremental task\nstatus: completed\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n",
+    );
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(0);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+
+    // This new Run overlaps an existing interval. Both activities' allocated
+    // duration must agree with a fresh calculation without rereading other Runs.
+    const newRun = join(root, ".agents/records/runs/2026/08/RUN-NEW.jsonl");
+    const rows = [started, usage(2, "openai", "gpt-a", 100, 50), { ...finished, sequence: 3 }].map(
+      (row, index) => ({
+        ...row,
+        run_id: "RUN-NEW",
+        event_id: `RUN-NEW:${index + 1}`,
+        ...(index === 0
+          ? { agent_invocation_id: "AINV-NEW", root_agent_invocation_id: "AINV-NEW" }
+          : {}),
+      }),
+    );
+    await writeFile(newRun, `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(1);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+    const editedRun = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const editedRows = (await readFile(editedRun, "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+    editedRows[1].tokens.input += 10;
+    editedRows[1].tokens.total += 10;
+    await writeFile(editedRun, `${editedRows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(1);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+    await rm(newRun);
+    await rm(task);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(0);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+  }, 120_000);
+
+  it("preserves historical checkpoints on the day boundary and rolls back failed delta publication", async () => {
+    const root = await fixture();
+    await prepareMultiProviderFixture(root);
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(new Date("2026-09-05T02:59:00Z"));
+    const first = await rebuildSqliteReadModel(root);
+    const history = inspect(first.path, historySql);
+    const schema = inspect(first.path, "PRAGMA schema_version");
+    vi.setSystemTime(new Date("2026-09-05T03:01:00Z"));
+    await rebuildSqliteReadModel(root);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    const path = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const content = await readFile(path, "utf8");
+    await writeFile(path, content.replace('"brl":5,', '"brl":8,'));
+    const exec = DatabaseSync.prototype.exec;
+    vi.spyOn(DatabaseSync.prototype, "exec").mockImplementation(function (
+      this: DatabaseSync,
+      sql: string,
+    ) {
+      if (sql.trim() === "COMMIT;") throw new Error("injected delta publication failure");
+      return exec.call(this, sql);
+    });
+    await expect(rebuildSqliteReadModel(root)).rejects.toThrow(
+      "injected delta publication failure",
+    );
+    vi.restoreAllMocks();
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await filesystem.readText(".agents/records/runs/2026/08/RUN-MULTI.jsonl")).toBe(
+        content,
+      );
+    } finally {
+      filesystem.close();
+    }
+    await rebuildSqliteReadModel(root);
+    await expectFullParity(root);
+  }, 120_000);
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-projection.ts

@@ -2,14 +2,29 @@ import type { DatabaseSync } from "node:sqlite";
 
 /** Persists the exact canonical Board summary so runtime pages never re-expand its lineage CTE. */
 export function materializeOperationsWorkProjection(database: DatabaseSync): void {
-  database.exec(`
-    CREATE TABLE operations_work_projection AS
+  const select = `
+    WITH changes AS MATERIALIZED (SELECT * FROM zaip_vw_canonical_changes),
+    work_items AS MATERIALIZED (SELECT * FROM zaip_vw_canonical_work_items),
+    fallback_changes AS MATERIALIZED (
+      SELECT task.value AS task_id, change.id,
+        ROW_NUMBER() OVER (PARTITION BY task.value ORDER BY change.created_at DESC, change.id DESC) AS preference
+      FROM changes change, json_each(change.task_ids_json) task
+    ),
+    resolved AS MATERIALIZED (
+      SELECT canonical.*, COALESCE(canonical.change_id, fallback.id) AS resolved_change_id
+      FROM work_items canonical
+      LEFT JOIN fallback_changes fallback ON fallback.task_id=canonical.id AND fallback.preference=1
+    )
     SELECT summary.*, canonical.stage, canonical.spec_id,
-      COALESCE(canonical.change_id, (SELECT change.id FROM canonical_changes change, json_each(change.task_ids_json) task WHERE task.value=canonical.id ORDER BY change.created_at DESC, change.id DESC LIMIT 1)) AS change_id,
-      (SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) AS origin,
-      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE((SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
+      canonical.resolved_change_id AS change_id, change.source_type AS origin,
+      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE(change.source_type IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
     FROM zaip_vw_operations_work_kanban summary
-    JOIN canonical_work_items canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id;
-    CREATE INDEX operations_work_projection_order ON operations_work_projection(occurred_at DESC, id DESC);
+    JOIN resolved canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id
+    LEFT JOIN changes change ON change.id=canonical.resolved_change_id`;
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS operations_work_projection AS ${select} LIMIT 0;
+    DELETE FROM operations_work_projection;
+    INSERT INTO operations_work_projection ${select};
+    CREATE INDEX IF NOT EXISTS operations_work_projection_order ON operations_work_projection(occurred_at DESC, id DESC);
   `);
 }

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

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import { expect } from "vitest";
 
 export function expectPersistedFirstFoldCaches(root: string, allTime: unknown, board: unknown) {
-  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,
   });
   try {

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

@@ -0,0 +1,42 @@
+import { parseYaml } from "@zaip-ai/core";
+
+export function frontMatterRecord(content: string): Record<string, unknown> | null {
+  const source = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
+  if (source === undefined) return null;
+  try {
+    const parsed = parseYaml(source);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function recordValue(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+export function stringValue(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+export function stringValues(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string")
+    : [];
+}
+
+export function consolidatedValue(values: readonly (string | null | undefined)[]): string | null {
+  const known = [
+    ...new Set(
+      values.filter(
+        (value): value is string =>
+          typeof value === "string" && value.length > 0 && value !== "unavailable",
+      ),
+    ),
+  ];
+  return known.length === 0 ? null : known.length === 1 ? known[0]! : "mixed";
+}