@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/tests/e2e/playwright.config.ts

@@ -7,17 +7,22 @@ const baseURL = process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${serverPor
 
 export default defineConfig({
   testDir: "./specs",
+  globalSetup: "./lease-global-setup.ts",
   fullyParallel: false,
   timeout: 180_000,
   expect: { timeout: 60_000 },
   retries: process.env.CI ? 1 : 0,
-  // CI shares one SQLite runtime across the suite. Serializing browser workers
-  // keeps the measured latency gates independent from runner CPU count.
-  ...(process.env.CI ? { workers: 1 } : {}),
+  // Every suite invocation shares one SQLite runtime, including local release
+  // qualification. Concurrent browser workers turn latency/export checks into
+  // an unintended load test whose result depends on the host CPU count.
+  workers: 1,
   reporter: process.env.CI ? "github" : "list",
   use: {
     baseURL: `${baseURL}/?token=e2e-token`,
-    trace: "off",
+    // Preserve a trace only when a test fails; it is the minimum durable
+    // diagnostic evidence without retaining artifacts for successful runs.
+    trace: "retain-on-failure",
+    screenshot: "only-on-failure",
   },
   projects: [{ name: "chromium", use: { ...devices["Desktop Chrome"] } }],
   webServer: {

package/templates/.agents/dashboard/tests/e2e/specs/cost-monitor-period-transition.spec.ts

@@ -4,6 +4,18 @@ const COST_MONITOR_PATH = "/api/v2/cost-monitor";
 const STALE_SUMMARY_SENTINEL = "SENTINELA-RESPOSTA-ANTIGA";
 const fiveSeconds = 5_000;
 
+test("reselecting the current bounded period never opens an unfinishable transition", async ({
+  page,
+}) => {
+  await openDashboard(page);
+  await selectThisMonth(page);
+  await expect(periodControl(page)).toHaveValue("this-month");
+  await periodControl(page).selectOption("this-month");
+  await expect(page.locator(".period-transition-overlay")).toHaveCount(0, { timeout: fiveSeconds });
+  await expect(periodControl(page)).toHaveValue("this-month");
+  await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
+});
+
 test("refreshes Cost Monitor within five seconds when Todo o Período is selected in place", async ({
   page,
 }) => {
@@ -86,12 +98,14 @@ test("does not let a late all-time summary overwrite the newer period", async ({
   });
   await page.addInitScript(() => {
     type Probe = {
+      armed: boolean;
       allTimeBody: string | null;
       allTimeFinished: boolean;
       allTimeStarted: boolean;
       releaseAllTime: null | (() => Promise<void>);
     };
     const probe: Probe = {
+      armed: false,
       allTimeBody: null,
       allTimeFinished: false,
       allTimeStarted: false,
@@ -109,7 +123,8 @@ test("does not let a late all-time summary overwrite the newer period", async ({
         url.searchParams.get("scope") === "summary" &&
         !url.searchParams.has("from") &&
         !url.searchParams.has("to");
-      if (!isAllTimeSummary || probe.allTimeStarted) return originalFetch(input, init);
+      if (!probe.armed || !isAllTimeSummary || probe.allTimeStarted)
+        return originalFetch(input, init);
 
       probe.allTimeStarted = true;
       return new Promise<Response>((resolve, reject) => {
@@ -138,7 +153,12 @@ test("does not let a late all-time summary overwrite the newer period", async ({
   const staleBody = withStaleSummarySentinel(priorPeriodBody!);
   await page.evaluate((body) => {
     window.__costSummaryStaleProbe.allTimeBody = body;
+    // Arm only after the bounded snapshot is ready. The default first paint
+    // also requests All Time; intercepting it can satisfy the later wait early
+    // and race React's commit rather than the stale-response guard.
+    window.__costSummaryStaleProbe.armed = true;
   }, staleBody);
+  expect(await page.evaluate(() => window.__costSummaryStaleProbe.allTimeStarted)).toBe(false);
 
   await periodControl(page).selectOption("all");
   await expect
@@ -160,6 +180,7 @@ test("does not let a late all-time summary overwrite the newer period", async ({
 declare global {
   interface Window {
     __costSummaryStaleProbe: {
+      armed: boolean;
       allTimeBody: string | null;
       allTimeFinished: boolean;
       allTimeStarted: boolean;

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

@@ -72,7 +72,7 @@ test("measures Cost, Operation and Traceability surfaces without full snapshot h
   const apiActivityAt = new Map<string, number>();
   page.on("request", (request) => {
     if (!request.url().includes("/api/v2/")) return;
-    if (isBackgroundReconciliation(request.url())) return;
+    if (isBackgroundReconciliation(request.url()) || isBrowserLease(request.url())) return;
     apiActivityAt.set(request.url(), performance.now());
     requestStartedAt.set(request, performance.now());
     apiRequestCount += 1;
@@ -81,7 +81,7 @@ test("measures Cost, Operation and Traceability surfaces without full snapshot h
   });
   const finishApiRequest = (request: { url(): string }) => {
     if (!request.url().includes("/api/v2/")) return;
-    if (isBackgroundReconciliation(request.url())) return;
+    if (isBackgroundReconciliation(request.url()) || isBrowserLease(request.url())) return;
     apiActivityAt.set(request.url(), performance.now());
     const count = activeApiRequests.get(request.url()) ?? 0;
     if (count <= 1) activeApiRequests.delete(request.url());
@@ -501,15 +501,18 @@ async function waitForQuietApiRequests(
     .poll(
       () => {
         const latestActivityAt = getLatestActivityAt();
-        return (
-          getActiveApiRequests().length === 0 &&
-          latestActivityAt !== null &&
-          performance.now() - latestActivityAt >= 500
-        );
+        return {
+          pending: getActiveApiRequests().map((url) => {
+            const parsed = new URL(url);
+            parsed.searchParams.delete("token");
+            return `${parsed.pathname}${parsed.search}`;
+          }),
+          settled: latestActivityAt !== null && performance.now() - latestActivityAt >= 500,
+        };
       },
       { timeout: 10_000 },
     )
-    .toBe(true);
+    .toEqual({ pending: [], settled: true });
 }
 
 async function selectedPeriodQuery(page: Page, period: Metric["period"]): Promise<PeriodQuery> {
@@ -540,6 +543,12 @@ function isBackgroundReconciliation(url: string): boolean {
   return new URL(url).pathname === "/api/v2/reconcile-open-work";
 }
 
+/** The browser's ownership stream intentionally stays open until page teardown.
+ * Its HTTP failures are still collected by the response listener above. */
+function isBrowserLease(url: string): boolean {
+  return new URL(url).pathname === "/api/v2/browser-lease";
+}
+
 async function assertCostPagination(
   page: Page,
   surface: Locator,

package/templates/.agents/dashboard/tests/e2e/specs/dashboard.spec.ts

@@ -169,7 +169,11 @@ test("renders the modern read-only dashboard and meets accessibility gates", asy
   const initialUrl = new URL(initialResponse.url());
   expect(initialUrl.searchParams.has("from")).toBe(false);
   expect(initialUrl.searchParams.has("to")).toBe(false);
-  await expect(page.getByRole("navigation", { name: "Dashboard Zaip AIOS menu" })).toBeVisible();
+  // Identity is loaded independently; both the initial title and the title
+  // with the observed repository identify the same accessible navigation.
+  await expect(
+    page.getByRole("navigation", { name: /^Dashboard Zaip AIOS(?: .+)? menu$/ }),
+  ).toBeVisible();
   const capabilityNav = page.getByRole("navigation", { name: "Áreas do dashboard" });
   const globalControls = page.locator(".dashboard-global-controls");
   await expect(capabilityNav).toBeVisible();
@@ -303,7 +307,8 @@ test("loads a quick Operations summary without full snapshot hydration", async (
   await expect(page.getByRole("heading", { name: "Status das PRDs" })).toBeVisible();
   await expect(page.getByRole("heading", { name: "Top 5 PRDs" })).toBeVisible();
   await expect(page.locator(".operations-run-bar").first()).toBeVisible();
-  expect(operationsRequests.some((url) => url.includes("scope=detail"))).toBe(true);
+  // Quick already contains the macro counts, chart data and Top 5 asserted above.
+  expect(operationsRequests.some((url) => url.includes("scope=detail"))).toBe(false);
 
   await selectOperations(page);
   await expect(page.getByLabel("Kanban de trabalho")).toBeVisible();
@@ -418,7 +423,7 @@ test("embeds traceability and keeps global settings and help available", async (
   await page.getByRole("button", { name: "Fechar ajuda" }).click();
 });
 
-test("groups macro work in All and reveals descendant Tasks only in Tasks", async ({ page }) => {
+test("filters the all-work board into Tasks, SPECs and PRDs after hydration", async ({ page }) => {
   await openDashboard(page);
   await selectPopulatedAllTime(page);
   await selectOperations(page);
@@ -427,15 +432,25 @@ test("groups macro work in All and reveals descendant Tasks only in Tasks", asyn
   const allItemCount = await boardItemCount(board);
 
   await page.getByRole("button", { exact: true, name: "Tarefas" }).click();
+  await expect(page.getByRole("button", { exact: true, name: "Tarefas" })).toHaveClass("is-active");
+  await expect(
+    board.locator(".operations-work-kind.is-spec, .operations-work-kind.is-prd"),
+  ).toHaveCount(0);
   const taskItemCount = await boardItemCount(board);
   expect(allItemCount).toBeGreaterThan(taskItemCount);
 
   await page.getByRole("button", { exact: true, name: "SPECs" }).click();
+  await expect(page.getByRole("button", { exact: true, name: "SPECs" })).toHaveClass("is-active");
+  await expect(
+    board.locator(".operations-work-kind.is-task, .operations-work-kind.is-prd"),
+  ).toHaveCount(0);
   const spec = page
     .locator(".operations-work-card")
     .filter({ has: page.locator(".operations-work-kind.is-spec") })
     .first();
-  if ((await spec.count()) === 0) {
+  // The quick projection already supplies global totals; a temporarily empty
+  // paginated DOM does not mean the selected entity collection is empty.
+  if ((await boardItemCount(board)) === 0) {
     await expect(
       page.getByLabel("Kanban de trabalho").locator(".operations-task-card"),
     ).toHaveCount(0);
@@ -448,11 +463,15 @@ test("groups macro work in All and reveals descendant Tasks only in Tasks", asyn
   }
 
   await page.getByRole("button", { exact: true, name: "PRDs" }).click();
+  await expect(page.getByRole("button", { exact: true, name: "PRDs" })).toHaveClass("is-active");
+  await expect(
+    board.locator(".operations-work-kind.is-task, .operations-work-kind.is-spec"),
+  ).toHaveCount(0);
   const prd = page
     .locator(".operations-work-card")
     .filter({ has: page.locator(".operations-work-kind.is-prd") })
     .first();
-  if ((await prd.count()) === 0) {
+  if ((await boardItemCount(board)) === 0) {
     await expect(
       page.getByLabel("Kanban de trabalho").locator(".operations-task-card"),
     ).toHaveCount(0);
@@ -540,6 +559,12 @@ test("shows the observed all-time macro duration consistently for SPEC and PRD",
 test("loads monthly overview quickly and keeps PRD and SPEC chart totals reconciled", async ({
   page,
 }) => {
+  const fullDetailRequests: string[] = [];
+  page.on("request", (request) => {
+    const url = new URL(request.url());
+    if (url.pathname === "/api/v2/operations" && url.searchParams.get("scope") === "detail")
+      fullDetailRequests.push(url.href);
+  });
   const openedAt = Date.now();
   const initialQuickResponse = await openDashboard(page);
   expect(Date.now() - openedAt).toBeLessThan(3_000);
@@ -601,6 +626,9 @@ test("loads monthly overview quickly and keeps PRD and SPEC chart totals reconci
       expect(donutCount).toBe(cardCount);
       expect(statusCounts.reduce((sum, value) => sum + Number(value), 0)).toBe(cardCount);
       expect(classificationCounts.reduce((sum, value) => sum + Number(value), 0)).toBe(cardCount);
+      // Macro metrics are already present in the exact quick response below.
+      // Clicking their cards must not start an unrelated full-history request.
+      expect(fullDetailRequests).toEqual([]);
 
       const macroKey = kind === "SPECs" ? "specs" : "prds";
       const macroDuration =
@@ -671,7 +699,20 @@ test("keeps aggregate KPIs visible without an obsolete coverage overlay", async
   await expect(page.locator(".operations-coverage-toast")).toHaveCount(0);
   await expect(page.getByRole("article", { name: /Tempo total de execu/ })).toBeVisible();
   await expect(page.getByRole("article", { name: /Tokens gastos/ })).toBeVisible();
-  await expect(page.getByRole("article", { name: /Custo Estimado/ })).toBeVisible();
+  const cost = page.getByRole("article", {
+    name: /^Custo Estimado:/,
+  });
+  await expect(cost).toBeVisible();
+  await expect(cost.locator("small")).toContainText(/\/ tarefa .*\/ hora/);
+  await expect(cost).not.toContainText("Subtotal estimado conhecido");
+  if (await cost.getAttribute("aria-description")) {
+    await expect(cost).toHaveAttribute("aria-description", /runs com custo conhecido/);
+    await expect(cost.locator("small")).toHaveText(
+      /R\$\s*[\d.,]+ \/ tarefa \(R\$\s*[\d.,]+ \/ hora\)/,
+    );
+    await expect(cost).not.toContainText("ⓘ");
+    await expect(cost).not.toContainText("indisponíveis por cobertura parcial");
+  }
 });
 
 async function openDashboard(page: import("@playwright/test").Page) {

package/templates/.agents/dashboard/tests/e2e/specs/lease-lifetime.spec.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "@playwright/test";
+
+test("keeps the suite-owned runtime alive across closed browser pages", async ({
+  page,
+  request,
+}) => {
+  await page.goto("/");
+  await page.close();
+  // Production launcher expiry is 12s: a replacement page must not race that deadline.
+  await new Promise((resolve) => setTimeout(resolve, 13_000));
+  const response = await request.get("/api/v2/health");
+  expect(response.status()).toBe(200);
+  expect(await response.json()).toMatchObject({ status: "ok" });
+});

package/templates/.agents/dashboard/tests/observability-fixture.mjs

@@ -0,0 +1,200 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+// Entirely synthetic acceptance fixtures, never real lifecycle evidence.
+const at = "2026-01-01T02:30:00.000Z"; // 2025-12-31 in Sao Paulo.
+export const cases = [
+  { suffix: "COMPLETE-A001", status: "completed", tokens: 15 },
+  { suffix: "FAILED-A002", status: "failed", tokens: null },
+  { suffix: "BLOCKED-A003", status: "blocked", tokens: 0 },
+].map((value) => ({
+  ...value,
+  task: `TASK-2026-01-01-00-00-${value.suffix}`,
+  change: `CHG-2026-01-01-00-00-${value.suffix}`,
+  run: `RUN-2026-01-01-00-00-${value.suffix}`,
+}));
+
+async function put(root, file, content) {
+  const target = join(root, file);
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, content, "utf8");
+}
+const markdown = (data) =>
+  `---\n${Object.entries(data)
+    .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+    .join("\n")}\n---\n\n# Synthetic observability qualification fixture\n`;
+
+export async function createObservabilityFixture(root) {
+  await put(
+    root,
+    ".agents/config/project.yaml",
+    "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: synthetic-observability\n  name: Synthetic observability\n  timezone: America/Sao_Paulo\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+  );
+  await put(
+    root,
+    ".agents/config/framework.lock.yaml",
+    "lock_version: 1\nframework:\n  version: 2.6.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+  );
+  for (const item of cases) {
+    const task = {
+      schema_version: 2,
+      id: item.task,
+      revision: 1,
+      change_id: item.change,
+      title: `Synthetic ${item.status}`,
+      short_name: item.suffix,
+      objective: "Synthetic cross-layer regression",
+      status: item.status,
+      attempt_count: item.status === "completed" ? 2 : 1,
+      risk: "standard",
+      priority: "medium",
+      owner: null,
+      requirement_ids: ["REQ-SYNTHETIC-001"],
+      acceptance_ids: ["AC-SYNTHETIC-001"],
+      depends_on: [],
+      write_scopes: ["synthetic/**"],
+      plan_revision: 1,
+      plan_hash: "a".repeat(64),
+      created_at: at,
+      updated_at: at,
+      started_at: at,
+      finished_at: item.status === "blocked" ? null : at,
+      result:
+        item.status === "blocked"
+          ? null
+          : {
+              summary: "Synthetic terminal fixture, not real approval",
+              changed_files: [],
+              evidence_ids: ["EVD-SYNTHETIC-FIXTURE"],
+              completed_run_id: item.run,
+            },
+    };
+    const change = {
+      schema_version: 2,
+      id: item.change,
+      revision: 1,
+      title: task.title,
+      status: item.status,
+      risk: "standard",
+      source: { type: "task", task_id: item.task },
+      requirement_ids: task.requirement_ids,
+      acceptance_ids: task.acceptance_ids,
+      requirement_impact: { type: "none", reason: "Synthetic fixture" },
+      task_ids: [item.task],
+      plan_revision: 1,
+      plan_hash: task.plan_hash,
+      created_at: at,
+      updated_at: at,
+      started_at: at,
+      finished_at: task.finished_at,
+      result: item.status === "blocked" ? null : "Synthetic fixture",
+    };
+    await put(root, `.agents/records/tasks/2026/01/${item.task}.md`, markdown(task));
+    await put(root, `.agents/records/changes/2026/01/${item.change}/change.md`, markdown(change));
+    const common = { schema_version: 2, run_id: item.run, occurred_at: at, phase: "execution" };
+    const records = [
+      {
+        ...common,
+        event_id: `${item.run}:1`,
+        sequence: 1,
+        type: "run.started",
+        attribution_status: "attributed",
+        run_role: "orchestrator",
+        run_purpose: "execution",
+        requires_finalizer: false,
+        execution_kind: "delivery",
+        execution_eligibility: ["delivery"],
+        entrypoint: "task",
+        work_type: item.status === "completed" ? "rework" : "new",
+        storage_mode: "tracked_sanitized",
+        client: "codex",
+        agent: "synthetic-agent",
+        agent_name: "synthetic-agent",
+        provider: "openai",
+        model: "synthetic-model",
+        reasoning_effort: null,
+        client_thread_id: `synthetic-${item.suffix}`,
+        client_turn_id: `synthetic-turn-${item.suffix}`,
+        conversation_id: `CONV-SYNTHETIC-${item.suffix}`,
+        execution_id: `EXEC-SYNTHETIC-${item.suffix}`,
+        task_id: item.task,
+        spec_id: null,
+        prd_id: null,
+        change_id: item.change,
+        parent_run_id: null,
+        continuation_of_run_id: null,
+        retry_of_run_id: item.status === "completed" ? `${item.run}-PRIOR` : null,
+      },
+    ];
+    if (item.tokens !== null)
+      records.push({
+        ...common,
+        event_id: `${item.run}:2`,
+        sequence: 2,
+        type: "usage.recorded",
+        activity_kind: "model_usage",
+        classification_source: "explicit",
+        tokens: {
+          input: item.tokens,
+          cached_input: 0,
+          output: 0,
+          reasoning: 0,
+          total: item.tokens,
+          source: "provider_reported",
+        },
+        cost: { usd: null, brl: null, fx_rate: null },
+        provider: "openai",
+        model: "synthetic-model",
+        source_segment_key: `synthetic-${item.suffix}`,
+        supersedes_event_id: null,
+      });
+    records.push({
+      ...common,
+      event_id: `${item.run}:${records.length + 1}`,
+      sequence: records.length + 1,
+      type: "run.finished",
+      status: item.status === "failed" ? "failed" : "completed",
+      duration_ms: null,
+      duration_provenance: null,
+    });
+    await put(
+      root,
+      `.agents/records/runs/2026/01/${item.run}.jsonl`,
+      `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+    );
+    if (item.status === "completed") {
+      for (const kind of ["PRIOR", "FINALIZER"]) {
+        const runId = `${item.run}-${kind}`;
+        const extra = records.map((record, index) => ({
+          ...record,
+          run_id: runId,
+          event_id: `${runId}:${index + 1}`,
+        }));
+        Object.assign(extra[0], {
+          run_role: kind === "FINALIZER" ? "subagent" : "orchestrator",
+          run_purpose: kind === "FINALIZER" ? "finalization" : "execution",
+          agent: kind === "FINALIZER" ? "zaip-agent-finalizer" : "synthetic-agent",
+          agent_name: kind === "FINALIZER" ? "zaip-agent-finalizer" : "synthetic-agent",
+          parent_run_id: kind === "FINALIZER" ? item.run : null,
+          retry_of_run_id: null,
+          client_turn_id: `synthetic-turn-${kind}`,
+        });
+        extra[1].tokens = {
+          input: 0,
+          cached_input: 0,
+          output: 0,
+          reasoning: 0,
+          total: 0,
+          source: "provider_reported",
+        };
+        extra.at(-1).status = kind === "PRIOR" ? "failed" : "completed";
+        await put(
+          root,
+          `.agents/records/runs/2026/01/${runId}.jsonl`,
+          `${extra.map((record) => JSON.stringify(record)).join("\n")}\n`,
+        );
+      }
+    }
+  }
+  return cases;
+}