@zaip-ai/cli 3.2.0 → 3.4.0

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard.mjs

@@ -93,6 +93,7 @@ import {
   presentLaunchFailure,
   writeLauncherStatus,
 } from "./start-dashboard-lifecycle.mjs";
+import { inspectDashboardOwnership } from "./start-dashboard-ownership.mjs";
 import { assertDashboardPrerequisites, exists } from "./start-dashboard-prerequisites.mjs";
 import {
   isKnownDashboardLauncher,
@@ -132,7 +133,8 @@ export async function readDashboardSession(path = sessionPath) {
   }
 }
 export async function writeDashboardSession(session, path = sessionPath) {
-  await writeJsonAtomic(path, session);
+  const { snapshotState: _obsoleteSnapshotState, ...identity } = session;
+  await writeJsonAtomic(path, identity);
 }
 export async function claimDashboardLaunch(
   { launchPort, token },
@@ -193,6 +195,7 @@ export async function claimDashboardLaunch(
     if (
       previous?.kind === claim.kind &&
       previous?.workspaceKey === workspaceKey &&
+      previous?.workspace === workspaceRoot &&
       Number.isInteger(previous?.launcherPid) &&
       previous.launcherPid > 0 &&
       previous.launcherPid !== process.pid
@@ -304,11 +307,11 @@ export async function probeDashboardPort(
 }
 export async function findReusableDashboardSession({
   path = sessionPath,
-  startPort = preferredPort(),
   fetchImpl = fetch,
   expectedWorkspaceKey = workspaceKey,
   expectedBuildSignature = null,
   expectedSnapshotState = "current",
+  inspectOwnership = inspectDashboardOwnership,
 } = {}) {
   const session = await readDashboardSession(path);
   if (
@@ -321,43 +324,19 @@ export async function findReusableDashboardSession({
   ) {
     return null;
   }
-  // Session metadata is written before the serving process finishes promoting
-  // a stale seed. Trust a state transition only after the owned server itself
-  // reports it; never reuse an unknown or still-updating generation as current.
-  if (expectedSnapshotState !== null && session.snapshotState !== expectedSnapshotState) {
-    if (!Number.isInteger(session.port)) return null;
-    try {
-      const response = await fetchImpl(dashboardHealthUrl(session.port), {
-        signal: AbortSignal.timeout(500),
-      });
-      const payload = await response.json();
-      if (
-        !response.ok ||
-        payload?.kind !== runtimeKind ||
-        payload?.workspaceKey !== expectedWorkspaceKey ||
-        payload?.snapshot_state !== expectedSnapshotState
-      )
-        return null;
-    } catch {
-      return null;
-    }
-  }
+  const health = await inspectOwnership(session, {
+    workspaceRoot,
+    workspaceKey: expectedWorkspaceKey,
+    fetchImpl,
+    host,
+  });
   if (
-    Number.isInteger(session.port) &&
-    (await probeDashboardPort(session.port, fetchImpl, expectedWorkspaceKey))
-  ) {
-    return session;
-  }
-  const ports = Array.from({ length: maxPortAttempts }, (_, index) => startPort + index).filter(
-    (port) => port <= 65_535 && port !== session.port,
-  );
-  const matches = await Promise.all(
-    ports.map(async (port) =>
-      (await probeDashboardPort(port, fetchImpl, expectedWorkspaceKey)) ? port : null,
-    ),
-  );
-  const port = matches.find((candidate) => candidate !== null);
-  return port === undefined ? null : { ...session, port };
+    health === null ||
+    health.status !== "ok" ||
+    (expectedSnapshotState !== null && health.snapshot_state !== expectedSnapshotState)
+  )
+    return null;
+  return session;
 }
 export function requestBackgroundProjectionRefresh(session, fetchImpl = fetch) {
   return fetchImpl(`http://${host}:${session.port}/api/v2/refresh-projection`, {
@@ -423,7 +402,7 @@ export async function withLauncherLock(
 }
 
 export function startDashboardLaunchPage(port) {
-  return createDashboardLaunchPage({ port, host, runtimeKind, healthPath, delay });
+  return createDashboardLaunchPage({ port, host, runtimeKind, healthPath, delay, workspaceRoot });
 }
 async function redirectLaunchPage(launchPage, target) {
   launchPage.setProgress({
@@ -464,6 +443,7 @@ async function stopOwnedDashboard(session) {
     fetchImpl: fetch,
     host,
     packageRoot,
+    workspaceRoot,
     delay,
   });
 }
@@ -471,10 +451,12 @@ export async function previousDashboardSessions({
   sessionPath: candidateSessionPath = sessionPath,
   registryPath: candidateRegistryPath = portRegistryPath,
   probe = (port) => probeDashboardPort(port, fetch, workspaceKey, false),
+  inspectOwnership = inspectDashboardOwnership,
 } = {}) {
   return collectPreviousDashboardSessions({
     candidateSessionPath,
     candidateRegistryPath,
+    inspectOwnership,
     probe,
     readDashboardSession,
     readPortRegistry,
@@ -642,10 +624,7 @@ async function main() {
             dbPath,
             buildSignature,
             generationId: `${process.pid}-${child.pid}-${port}-${randomBytes(6).toString("hex")}`,
-            // The serving process owns the stale-seed refresh and promotes it
-            // into this session, so a later click can reuse the current
-            // generation after the health state flips.
-            snapshotState: snapshotCache === "stale_seed" ? "updating" : "current",
+            // Snapshot state belongs exclusively to the live health/ready endpoints.
             createdAt: new Date().toISOString(),
           };
           await assertCurrentLaunch();
@@ -719,12 +698,27 @@ async function waitForDashboard(port, child) {
     try {
       const response = await fetch(dashboardHealthUrl(port), { signal: AbortSignal.timeout(750) });
       const payload = await response.json().catch(() => null);
-      if (response.ok && payload?.kind === runtimeKind && payload?.workspaceKey === workspaceKey) {
+      if (
+        payload?.kind === runtimeKind &&
+        payload?.workspaceKey === workspaceKey &&
+        payload?.workspace === workspaceRoot &&
+        payload?.server_pid === child.pid &&
+        (response.ok || payload.status === "degraded")
+      ) {
         const readiness = await fetch(`http://${host}:${port}/api/v2/ready`, {
           signal: AbortSignal.timeout(750),
           cache: "no-store",
         });
-        if (readiness.ok) return;
+        const readinessPayload = await readiness
+          .clone()
+          .json()
+          .catch(() => null);
+        if (
+          readiness.ok ||
+          (readinessPayload?.status === "degraded" &&
+            ["missing", "invalid"].includes(readinessPayload.lifecycle_manifest_state))
+        )
+          return;
         if (readiness.status >= 500) {
           const detail = await readiness.json().catch(() => null);
           const unavailable = new Error(

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard.test.mjs

@@ -468,11 +468,13 @@ describe("dashboard executable session", () => {
     const reusable = await findReusableDashboardSession({
       path,
       expectedBuildSignature: "compatible-build",
+      inspectOwnership: async () => ({ status: "ok", snapshot_state: "current" }),
       fetchImpl: async () =>
         new Response(JSON.stringify({ kind: runtimeKind, workspaceKey }), { status: 200 }),
     });
 
-    expect(reusable).toEqual(session);
+    const { snapshotState, ...identity } = session;
+    expect(reusable).toEqual(identity);
     expect(reusable).toMatchObject({ port: 4317, serverPid: 5678 });
   });
 
@@ -655,6 +657,7 @@ describe("dashboard executable session", () => {
         sessionPath: join(directory, "missing-session.json"),
         registryPath: path,
         probe: async () => true,
+        inspectOwnership: async () => ({ status: "ok" }),
       }),
     ).resolves.toEqual([expect.objectContaining({ port: 4317, rootPid: 1234, status: "closed" })]);
   });
@@ -743,7 +746,7 @@ describe("dashboard executable session", () => {
     expect(buildSignature).toBeGreaterThan(lock);
     expect(previous).toBeGreaterThan(buildSignature);
     expect(source).toContain("newestClickWins: true,");
-    expect(source).toContain(
+    expect(source).not.toContain(
       'snapshotState: snapshotCache === "stale_seed" ? "updating" : "current",',
     );
     expect(source).toContain("presentLaunchFailure(launchPage, error, formatLauncherError)");

package/templates/.agents/dashboard/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-ui",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/scripts/qualify-macro-overview.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../..");
+const mode = process.argv[2];
+assert(["test", "check", "integration"].includes(mode), "Expected test|check|integration");
+function run(args, cwd = root) {
+  const result = spawnSync(process.execPath, args, {
+    cwd,
+    windowsHide: true,
+    stdio: "inherit",
+    timeout: 300_000,
+    env: { ...process.env, CI: "true" },
+  });
+  if (result.error) throw result.error;
+  assert.equal(result.status, 0, `Check failed: ${args.join(" ")}`);
+}
+
+if (!existsSync(join(root, "node_modules/vitest/vitest.mjs"))) {
+  run([
+    join(dirname(process.execPath), "node_modules/corepack/dist/pnpm.js"),
+    "install",
+    "--offline",
+    "--frozen-lockfile",
+    "--ignore-scripts",
+  ]);
+}
+const runtime = ".agents/dashboard/packages/local-runtime";
+const operations = ".agents/dashboard/modules/operations";
+if (mode === "check") {
+  for (const directory of [runtime, operations]) {
+    run([join(root, "node_modules/typescript/bin/tsc"), "--noEmit"], join(root, directory));
+  }
+} else {
+  const tests =
+    mode === "test"
+      ? [
+          `${runtime}/src/sqlite-first-fold-cache.test.ts`,
+          `${runtime}/src/server-period-macro-metric.test.ts`,
+          `${operations}/src/react/OperationsOverview.test.ts`,
+        ]
+      : [
+          `${runtime}/src/sqlite-force-canonical.test.ts`,
+          `${runtime}/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts`,
+          `${runtime}/src/server-overview.test.ts`,
+        ];
+  run([join(root, "node_modules/vitest/vitest.mjs"), "run", ...tests]);
+}

package/templates/.agents/dashboard/tests/e2e/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-e2e",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "private": true,
   "type": "module",
   "scripts": {

package/templates/.agents/dashboard/tests/e2e/specs/dashboard-performance-matrix.spec.ts

@@ -1,4 +1,5 @@
 import { expect, type Locator, type Page, test } from "@playwright/test";
+import { exportRowIdentity } from "./export-row-identity.js";
 
 type Metric = {
   surface: string;
@@ -710,24 +711,6 @@ function assertCompleteExport(pages: SqlitePage[]) {
   expect(pages.at(-1)?.has_more).toBe(false);
 }
 
-function exportRowIdentity(row: Record<string, unknown>): string {
-  for (const key of [
-    "agent_invocation_id",
-    "execution_id",
-    "conversation_id",
-    "task_id",
-    "spec_id",
-    "prd_id",
-    "period_key",
-    "key",
-    "id",
-  ]) {
-    const value = row[key];
-    if (typeof value === "string" && value.length > 0) return `${key}:${value}`;
-  }
-  return JSON.stringify(row);
-}
-
 async function exportCloseCount(page: Page): Promise<number> {
   return page.evaluate(
     () => (window as Window & { __zaipExportCloseCount?: number }).__zaipExportCloseCount ?? 0,

package/templates/.agents/dashboard/tests/e2e/specs/export-row-identity.spec.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "@playwright/test";
+import { exportRowIdentity } from "./export-row-identity.js";
+
+test("export identity distinguishes sibling Tasks and still detects actual duplicates", () => {
+  const first = { entity_kind: "task", id: "TASK-A", spec_id: "SPEC-SHARED", prd_id: "PRD-SHARED" };
+  const second = { ...first, id: "TASK-B" };
+  const identities = [first, second].map(exportRowIdentity);
+  expect(new Set(identities).size).toBe(2);
+  expect(exportRowIdentity({ ...first })).toBe(identities[0]);
+  expect(exportRowIdentity({ ...first, entity_kind: "spec" })).not.toBe(identities[0]);
+});
+
+test("cost export keeps its own invocation identity ahead of parent references", () => {
+  expect(
+    exportRowIdentity({ agent_invocation_id: "AINV-A", task_id: "TASK-A", spec_id: "SPEC-A" }),
+  ).toBe("agent_invocation_id:AINV-A");
+  expect(exportRowIdentity({ execution_id: "EXEC-A", task_id: "TASK-A" })).toBe(
+    "execution_id:EXEC-A",
+  );
+});

package/templates/.agents/dashboard/tests/e2e/specs/export-row-identity.ts

@@ -0,0 +1,20 @@
+export function exportRowIdentity(row: Record<string, unknown>): string {
+  if (typeof row.entity_kind === "string" && typeof row.id === "string" && row.id.length > 0) {
+    return `${row.entity_kind}:${row.id}`;
+  }
+  for (const key of [
+    "agent_invocation_id",
+    "execution_id",
+    "conversation_id",
+    "task_id",
+    "spec_id",
+    "prd_id",
+    "period_key",
+    "key",
+    "id",
+  ]) {
+    const value = row[key];
+    if (typeof value === "string" && value.length > 0) return `${key}:${value}`;
+  }
+  return JSON.stringify(row);
+}