@zaip-ai/cli 1.3.8 → 1.4.1

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

@@ -0,0 +1,270 @@
+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 { expectFastCostPagesMatchCanonical } from "./sqlite-cost-fast-page-parity.test-support.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
+async function createSqliteTestRoot(): Promise<string> {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
+}
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("SQLite dashboard read model multi-provider", () => {
+  it("counts task participation per observed model while retaining canonical structural attribution", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    await mkdir(join(root, ".agents", "records", "tasks", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "specs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "records", "prds", "2026", "08"), { recursive: true });
+    await mkdir(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CREATED",
+        "artifacts",
+        "tests",
+      ),
+      { recursive: true },
+    );
+    await mkdir(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CREATED",
+        "artifacts",
+        "evidence",
+      ),
+      { recursive: true },
+    );
+    const creationStarted = {
+      ...started,
+      event_id: "RUN-CREATION:1",
+      run_id: "RUN-CREATION",
+      model: "gpt-a",
+      provider: "openai",
+      agent_invocation_id: "AINV-CREATION",
+      root_agent_invocation_id: "AINV-CREATION",
+      task_id: "TASK-CREATED",
+      spec_id: null,
+      prd_id: null,
+    };
+    const creationUsage = {
+      ...usage(2, "openai", "gpt-a", 4, 2),
+      event_id: "RUN-CREATION:2",
+      run_id: "RUN-CREATION",
+      source_segment_key: "creation",
+      model_call_id: "MCALL-CREATION",
+    };
+    const creationFinished = {
+      ...finished,
+      event_id: "RUN-CREATION:3",
+      run_id: "RUN-CREATION",
+      sequence: 3,
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-CREATION.jsonl"),
+      `${[creationStarted, creationUsage, creationFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    const created = (id: string) =>
+      `---\nid: ${id}\ntitle: Created\nstatus: completed\ncreation_run_id: RUN-CREATION\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n`;
+    await writeFile(
+      join(root, ".agents", "records", "tasks", "2026", "08", "TASK-CREATED.md"),
+      created("TASK-CREATED"),
+    );
+    await writeFile(
+      join(root, ".agents", "records", "specs", "2026", "08", "SPEC-CREATED.md"),
+      created("SPEC-CREATED"),
+    );
+    await writeFile(
+      join(root, ".agents", "records", "prds", "2026", "08", "PRD-CREATED.md"),
+      created("PRD-CREATED"),
+    );
+    const artifact = (id: string, kind: string) =>
+      `---\nid: ${id}\nkind: ${kind}\ntask_id: TASK-CREATED\nrun_id: RUN-CREATION\nexecuted_at: 2026-08-04T12:02:00.000Z\nstatus: passed\n---\n`;
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CREATED",
+        "artifacts",
+        "tests",
+        "TEST-CREATED.md",
+      ),
+      artifact("TEST-CREATED", "test"),
+    );
+    await writeFile(
+      join(
+        root,
+        ".agents",
+        "records",
+        "changes",
+        "2026",
+        "08",
+        "CHG-CREATED",
+        "artifacts",
+        "evidence",
+        "EVD-CREATED.md",
+      ),
+      artifact("EVD-CREATED", "evidence"),
+    );
+    const directConversationRun = (id: string, provider: string, model: string) => {
+      const directStarted = {
+        ...started,
+        event_id: `${id}:1`,
+        run_id: id,
+        conversation_id: "CONV-DIRECT-MULTI",
+        task_id: "TASK-LEGACY-ONLY",
+        provider,
+        model,
+      };
+      delete (directStarted as { agent_invocation_id?: string }).agent_invocation_id;
+      delete (directStarted as { root_agent_invocation_id?: string }).root_agent_invocation_id;
+      const directUsage = {
+        ...usage(2, provider, model, 3, 1),
+        event_id: `${id}:2`,
+        run_id: id,
+      };
+      const directFinished = { ...finished, event_id: `${id}:3`, run_id: id, sequence: 3 };
+      return [directStarted, directUsage, directFinished];
+    };
+    for (const [id, provider, model] of [
+      ["RUN-DIRECT-GPT", "openai", "gpt-a"],
+      ["RUN-DIRECT-CLAUDE", "anthropic", "claude-b"],
+    ] as const)
+      await writeFile(
+        join(root, ".agents", "records", "runs", "2026", "08", `${id}.jsonl`),
+        `${directConversationRun(id, provider, model)
+          .map((row) => JSON.stringify(row))
+          .join("\n")}\n`,
+      );
+    // An agent Run may have a residual unknown model while still exposing a
+    // factual conversation_id. It counts once in unavailable, never as Task.
+    const unknownConversationStarted = {
+      ...started,
+      event_id: "RUN-UNKNOWN-CONVERSATION:1",
+      run_id: "RUN-UNKNOWN-CONVERSATION",
+      conversation_id: "CONV-UNKNOWN-MODEL",
+      task_id: null,
+      entrypoint: "conversation",
+      provider: "openai",
+      model: "unavailable",
+      agent_invocation_id: "AINV-UNKNOWN-CONVERSATION",
+      root_agent_invocation_id: "AINV-UNKNOWN-CONVERSATION",
+    };
+    const unknownConversationUsage = {
+      ...usage(2, "openai", "unavailable", 1, 1),
+      event_id: "RUN-UNKNOWN-CONVERSATION:2",
+      run_id: "RUN-UNKNOWN-CONVERSATION",
+      source_segment_key: "unknown-conversation",
+      model_call_id: "MCALL-UNKNOWN-CONVERSATION",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNKNOWN-CONVERSATION.jsonl"),
+      `${[unknownConversationStarted, unknownConversationUsage, { ...finished, event_id: "RUN-UNKNOWN-CONVERSATION:3", run_id: "RUN-UNKNOWN-CONVERSATION", sequence: 3 }].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      const models = filesystem.viewPage("cost_monitor_models", { limit: 20 });
+      expect(models.rows.find((row) => row.key === "gpt-a")).toMatchObject({
+        task_count: 2,
+        spec_count: 1,
+        prd_count: 1,
+        validation_count: 1,
+        evidence_count: 1,
+      });
+      // RUN-MULTI used both models for its linked Task. Model membership is
+      // consequently additive in the footer, while structural facts remain
+      // independently attributed through their creation Run.
+      expect(models.rows.find((row) => row.key === "claude-b")).toMatchObject({
+        task_count: 1,
+        spec_count: 0,
+        prd_count: 0,
+        validation_count: 0,
+        evidence_count: 0,
+      });
+      expect(models.rows.find((row) => row.key === "gpt-a")).toMatchObject({
+        conversation_count: 2,
+      });
+      expect(models.rows.find((row) => row.key === "claude-b")).toMatchObject({
+        conversation_count: 1,
+      });
+      expect(models.rows.map((row) => row.key)).not.toContain("unavailable");
+      expect(models.totals).toMatchObject({
+        task_count: 3,
+        spec_count: 1,
+        prd_count: 1,
+        validation_count: 1,
+        evidence_count: 1,
+      });
+      expect(models.totals?.task_count).toBe(
+        models.rows.reduce((sum, row) => sum + Number(row.task_count), 0),
+      );
+      expect((models.totals as Record<string, unknown> | undefined)?.conversation_count).toBe(3);
+      expect((models.totals as Record<string, unknown> | undefined)?.conversation_count).toBe(
+        models.rows.reduce((sum, row) => sum + Number(row.conversation_count), 0),
+      );
+      const periodModels = filesystem.viewPage("cost_monitor_models", {
+        from: "2026-08-04",
+        to: "2026-08-04",
+        limit: 20,
+      });
+      expect(periodModels.rows.map((row) => row.key)).not.toContain("unavailable");
+      expect((periodModels.totals as Record<string, unknown>).conversation_count).toBe(3);
+      expect(periodModels.rows.find((row) => row.key === "gpt-a")).toMatchObject({
+        task_count: 2,
+        spec_count: 1,
+        prd_count: 1,
+        validation_count: 1,
+        evidence_count: 1,
+      });
+      expect(periodModels.totals).toMatchObject({
+        task_count: 3,
+        spec_count: 1,
+        prd_count: 1,
+        validation_count: 1,
+        evidence_count: 1,
+      });
+      const filteredModels = filesystem.viewPage("cost_monitor_models", {
+        from: "2026-08-04",
+        to: "2026-08-04",
+        provider: "openai",
+        model: "gpt-a",
+        limit: 20,
+      });
+      expect(filteredModels.rows.find((row) => row.key === "gpt-a")).toMatchObject({
+        task_count: 2,
+        spec_count: 1,
+        prd_count: 1,
+        validation_count: 1,
+        evidence_count: 1,
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-multi-provider-fixture.ts

@@ -192,8 +192,9 @@ export async function prepareMultiProviderFixture(root: string) {
     join(root, ".agents", "records", "runs", "2026", "08", "RUN-UNAVAILABLE.jsonl"),
     `${[unavailableStarted, unavailableUsage, unavailableFinished].map((row) => JSON.stringify(row)).join("\n")}\n`,
   );
-  // It is a canonical activity but not an Agent Invocation. Cost Monitor
-  // must not blend this population into its token/cost/session rate.
+  // It is a canonical unassisted turn, not an Agent Invocation. Its legacy
+  // task_id is correlation metadata: Models counts its conversation, never a
+  // second Task participation.
   const {
     agent_invocation_id: _invocation,
     root_agent_invocation_id: _rootInvocation,

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

@@ -42,7 +42,7 @@ describe("SQLite dashboard read model multi-provider", () => {
     const { started, usage, finished } = await prepareMultiProviderFixture(root);
     await rebuildSqliteReadModel(root);
     const aggregateDatabase = new DatabaseSync(
-      resolve(root, ".local/dashboard-sqlite/read-model.sqlite"),
+      resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"),
       {
         readOnly: true,
       },
@@ -296,7 +296,7 @@ describe("SQLite dashboard read model multi-provider", () => {
         expect.objectContaining({ key: "claude-b", total_tokens: 20, estimated_brl: 10 }),
       ]),
     );
-    expect(modelGroups.rows.map((row) => row.key)).toEqual(expect.arrayContaining(["unavailable"]));
+    expect(modelGroups.rows.map((row) => row.key)).not.toContain("unavailable");
     const modelTotals = modelGroups.rows.reduce<{
       invocations: number;
       tasks: number;
@@ -314,12 +314,26 @@ describe("SQLite dashboard read model multi-provider", () => {
       { invocations: 0, tasks: 0, duration: 0, tokens: 0, brl: 0 },
     );
     expect(modelTotals).toEqual({
-      invocations: 2,
-      tasks: 3,
+      // The unavailable residual is retained in canonical facts and Provider
+      // rows, but excluded from the displayed Models population.
+      invocations: 1,
+      // The remaining legacy unassisted turn carries task_id only as
+      // correlation metadata. It is a Conversation, not another Task.
+      tasks: 2,
       duration: 60_000,
       tokens: 1030,
       brl: 515,
     });
+    // RUN-UNASSISTED retains its legacy task_id for correlation, but its
+    // observed conversation belongs to gpt-a without adding a Task.
+    expect(modelGroups.rows.find((row) => row.key === "gpt-a")).toMatchObject({
+      task_count: 1,
+      conversation_count: 1,
+    });
+    expect(Number((modelGroups.totals as Record<string, unknown>).conversation_count)).toBe(1);
+    expect(
+      modelGroups.rows.reduce((sum, row) => sum + Number(row.conversation_count ?? 0), 0),
+    ).toBe(1);
     expect(filesystem.viewPage("cost_monitor_models", { query: "gpt-a" }).rows).toHaveLength(1);
     expect(
       filesystem.viewPage("cost_monitor_models", { provider: "openai", model: "gpt-a" }).rows[0],

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

@@ -0,0 +1,87 @@
+import { mkdir, mkdtemp, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  type SqliteReadModelSourceCandidate,
+  sourceFingerprint,
+} from "./sqlite-read-model-source-fingerprint.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, "fingerprint-"));
+  roots.push(root);
+  await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+  const path = join(root, ".agents/records/tasks/task.md");
+  await writeFile(path, "# first\n");
+  return { root, path };
+}
+const checkpoints = (candidates: SqliteReadModelSourceCandidate[]) =>
+  new Map(candidates.map((candidate) => [candidate.source, candidate]));
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("persistent source fingerprint checkpoints", () => {
+  it("reuses historical content hashes across serialized checkpoints and detects additions and removals", async () => {
+    const { root, path } = await fixture();
+    const initial = await sourceFingerprint(root);
+    const previous = checkpoints(JSON.parse(JSON.stringify(initial.candidates)));
+    expect(initial.hashedFiles).toBe(1);
+    const unchanged = await sourceFingerprint(root, { previous });
+    expect(unchanged).toMatchObject({
+      fingerprint: initial.fingerprint,
+      hashedFiles: 0,
+      reusedFiles: 1,
+    });
+    await writeFile(join(root, ".agents/records/tasks/new.md"), "# new\n");
+    const added = await sourceFingerprint(root, { previous });
+    expect(added).toMatchObject({ hashedFiles: 1, reusedFiles: 1 });
+    expect(added.candidates).toHaveLength(2);
+    await rm(path);
+    const removed = await sourceFingerprint(root, { previous: checkpoints(added.candidates) });
+    expect(removed).toMatchObject({ hashedFiles: 0, reusedFiles: 1 });
+    expect(removed.candidates.map((candidate) => candidate.source)).toEqual([
+      ".agents/records/tasks/new.md",
+    ]);
+    expect(removed.fingerprint).not.toBe(added.fingerprint);
+  });
+
+  it("detects same-size content changes when the previous modification time is restored", async () => {
+    const { root, path } = await fixture();
+    // Exact second precision makes the preserved mtime assertion portable.
+    const timestamp = new Date("2026-01-01T00:00:00Z");
+    await utimes(path, timestamp, timestamp);
+    const initial = await sourceFingerprint(root);
+    await writeFile(path, "# other\n");
+    await utimes(path, timestamp, timestamp);
+    const changed = await sourceFingerprint(root, { previous: checkpoints(initial.candidates) });
+    expect(changed.candidates[0]?.mtimeMs).toBe(initial.candidates[0]?.mtimeMs);
+    expect(changed.candidates[0]?.size).toBe(initial.candidates[0]?.size);
+    expect(changed.candidates[0]?.contentHash).not.toBe(initial.candidates[0]?.contentHash);
+    expect(changed).toMatchObject({ hashedFiles: 1, reusedFiles: 0 });
+  });
+
+  it("detects atomic file replacement and allows explicit complete content verification", async () => {
+    const { root, path } = await fixture();
+    const initial = await sourceFingerprint(root);
+    const metadata = await stat(path);
+    const replacement = `${path}.replacement`;
+    await writeFile(replacement, "# other\n");
+    await utimes(replacement, metadata.atime, metadata.mtime);
+    await rename(replacement, path);
+    const changed = await sourceFingerprint(root, { previous: checkpoints(initial.candidates) });
+    expect(changed.fingerprint).not.toBe(initial.fingerprint);
+    const verified = await sourceFingerprint(root, {
+      previous: checkpoints(changed.candidates),
+      verifyContent: true,
+    });
+    expect(verified).toMatchObject({
+      fingerprint: changed.fingerprint,
+      hashedFiles: 1,
+      reusedFiles: 0,
+    });
+  });
+});

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

@@ -1,4 +1,5 @@
-import { readdir, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 
 const textExtensions = new Set([".json", ".jsonl", ".md", ".yaml", ".yml", ".txt"]);
@@ -32,14 +33,41 @@ export type SqliteReadModelSourceCandidate = {
   source: string;
   mtimeMs: number;
   size: number;
+  contentHash: string;
+  ctimeMs: number;
+  fileIdentity: string;
+};
+
+export type SqliteReadModelSourceCheckpoint = Omit<SqliteReadModelSourceCandidate, "path">;
+
+type FingerprintOptions = {
+  previous?: ReadonlyMap<string, SqliteReadModelSourceCheckpoint>;
+  verifyContent?: boolean;
 };
 
 export async function sourceFingerprint(
   workspaceRoot: string,
-): Promise<{ fingerprint: string; candidates: SqliteReadModelSourceCandidate[] }> {
+  options: FingerprintOptions = {},
+): Promise<{
+  fingerprint: string;
+  candidates: SqliteReadModelSourceCandidate[];
+  hashedFiles: number;
+  reusedFiles: number;
+}> {
   const candidates = (
     await Promise.all(
-      [".agents/records", ".agents/config"].map((root) => listFiles(resolve(workspaceRoot, root))),
+      [
+        ".agents/config",
+        ...[
+          "tasks",
+          "specs",
+          "prds",
+          "runs",
+          "executions",
+          "changes",
+          "lifecycle/historical-developer-attribution",
+        ].map((kind) => `.agents/records/${kind}`),
+      ].map((root) => listFiles(resolve(workspaceRoot, root))),
     )
   )
     .flat()
@@ -49,27 +77,88 @@ export async function sourceFingerprint(
         isDashboardCanonicalSource(relative(workspaceRoot, path).replaceAll("\\", "/")),
     )
     .sort();
-  const candidatesWithMetadata = await Promise.all(
-    candidates.map(async (candidate) => {
-      const metadata = await stat(candidate);
-      return {
-        path: candidate,
-        source: relative(workspaceRoot, candidate).replaceAll("\\", "/"),
-        mtimeMs: Math.trunc(metadata.mtimeMs),
-        size: metadata.size,
-      };
-    }),
-  );
+  const candidatesWithMetadata: SqliteReadModelSourceCandidate[] = [];
+  let hashedFiles = 0;
+  let reusedFiles = 0;
+  // Persisted checkpoints avoid rereading unchanged history across workers.
+  // ctime and identity detect same-size edits with preserved mtime and atomic
+  // replacement. Explicit verification bypasses this metadata shortcut.
+  for (let offset = 0; offset < candidates.length; offset += 32) {
+    candidatesWithMetadata.push(
+      ...(
+        await Promise.all(
+          candidates.slice(offset, offset + 32).map(async (candidate) => {
+            const source = relative(workspaceRoot, candidate).replaceAll("\\", "/");
+            try {
+              for (let attempt = 0; attempt < 3; attempt += 1) {
+                const metadata = await stat(candidate);
+                const current = {
+                  path: candidate,
+                  source,
+                  mtimeMs: metadata.mtimeMs,
+                  ctimeMs: metadata.ctimeMs,
+                  size: metadata.size,
+                  fileIdentity: `${metadata.dev}:${metadata.ino}:${metadata.birthtimeMs}`,
+                };
+                const previous = options.previous?.get(source);
+                if (
+                  !options.verifyContent &&
+                  previous !== undefined &&
+                  previous.mtimeMs === current.mtimeMs &&
+                  previous.ctimeMs === current.ctimeMs &&
+                  previous.size === current.size &&
+                  previous.fileIdentity === current.fileIdentity
+                ) {
+                  reusedFiles += 1;
+                  return { ...current, contentHash: previous.contentHash };
+                }
+                const contentHash = createHash("sha256")
+                  .update(await readFile(candidate))
+                  .digest("hex");
+                const after = await stat(candidate);
+                if (
+                  metadata.mtimeMs !== after.mtimeMs ||
+                  metadata.ctimeMs !== after.ctimeMs ||
+                  metadata.size !== after.size ||
+                  metadata.ino !== after.ino ||
+                  metadata.dev !== after.dev ||
+                  metadata.birthtimeMs !== after.birthtimeMs
+                )
+                  continue;
+                hashedFiles += 1;
+                return { ...current, contentHash };
+              }
+              throw new Error(`Canonical source changed repeatedly during refresh: ${source}`);
+            } catch (error) {
+              // Concurrent removals are represented by absence in this snapshot.
+              if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+              throw error;
+            }
+          }),
+        )
+      ).filter((candidate): candidate is SqliteReadModelSourceCandidate => candidate !== null),
+    );
+  }
   return {
     fingerprint: candidatesWithMetadata
-      .map((candidate) => `${candidate.source}:${candidate.mtimeMs}:${candidate.size}`)
+      .map(
+        (candidate) =>
+          `${candidate.source}:${candidate.mtimeMs}:${candidate.size}:${candidate.contentHash}`,
+      )
       .join("|"),
     candidates: candidatesWithMetadata,
+    hashedFiles,
+    reusedFiles,
   };
 }
 
 async function listFiles(directory: string): Promise<string[]> {
-  const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir(directory, { withFileTypes: true }).catch(
+    (error: NodeJS.ErrnoException) => {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    },
+  );
   return (
     await Promise.all(
       entries.map(async (entry) => {