@zaip-ai/cli 6.2.0 → 7.5.0

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

@@ -130,9 +130,8 @@ describe("SQLite dashboard read model multi-provider", () => {
     expect(
       allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_usd ?? 0), 0),
     ).toBe(allCostTotals.total_cost_usd);
-    // The calendar overview uses three observed one-minute source intervals.
-    // The agent table reports 120 seconds attributable to token-active facts;
-    // it does not assign the remaining source elapsed minute to an Agent.
+    // Calendar: three source minutes; agent table: only two token-active minutes.
+    // The remaining source minute is not assigned to an Agent.
     expect(allCostTotals.cost_monitor_total_duration).toBe(180_000);
     expect(allAgentGroups.totals).toMatchObject({
       invocation_count: allCostTotals.total_run_count,
@@ -147,8 +146,7 @@ describe("SQLite dashboard read model multi-provider", () => {
     ] as const) {
       const rows = filesystem.invocationCostRows({ from: null, to: null, providers, models });
       expect(rows).toHaveLength(1);
-      // Membership is segment-based; once the invocation matches, its
-      // canonical invocation totals remain intact rather than being split.
+      // Segment-based membership retains the matching invocation's entire totals.
       expect(rows[0]).toMatchObject({ total_tokens: 30, cost_brl: 15 });
       expect([
         ...filesystem.executionDurationByDay({ from: null, to: null, providers, models }).values(),
@@ -168,9 +166,10 @@ describe("SQLite dashboard read model multi-provider", () => {
           offset: 0,
         });
         expect(page.rows[0]).toMatchObject({
-          total_run_count: 1,
-          total_tokens: 30,
-          total_cost_brl: 15,
+          // Financial pages also include the legacy unassisted OpenAI Run.
+          total_run_count: providers[0] === "openai" ? 2 : 1,
+          total_tokens: providers[0] === "openai" ? 1_030 : 30,
+          total_cost_brl: providers[0] === "openai" ? 515 : 15,
         });
       }
       const agents = filesystem.viewPage("cost_monitor_zaip_agents", {
@@ -224,14 +223,10 @@ describe("SQLite dashboard read model multi-provider", () => {
       "cost_monitor_monthly",
       "cost_monitor_annual",
     ] as const) {
-      // Lifecycle buckets can remain present independently, but the crossed
-      // pair must contribute no invocation financial or Run facts.
-      const row = filesystem.viewPage(view, { provider: "openai", model: "claude-b" }).rows[0];
-      expect(row).toMatchObject({
-        total_run_count: 0,
-        total_duration: null,
-        total_tokens: null,
-        total_cost_brl: null,
+      // No activity matches this provider/model pair; no financial bucket exists.
+      expect(filesystem.viewPage(view, { provider: "openai", model: "claude-b" })).toMatchObject({
+        total_count: 0,
+        rows: [],
       });
     }
     for (const view of [
@@ -356,9 +351,8 @@ describe("SQLite dashboard read model multi-provider", () => {
     // Observed zero telemetry stays zero, while the missing provider/model
     // attribute selects this segment rather than a literal sentinel value.
     expect(unavailableRows[0]).toMatchObject({ total_tokens: 0, cost_brl: 0 });
-    // Execution-duration is an Operations compatibility aggregate and still
-    // includes the unassisted canonical Run. Cost Monitor retains its
-    // measurable financial activity as an unavailable historical fact.
+    // Operations compatibility includes the unassisted Run here; financial
+    // calendar attributes its known usage to OpenAI, not unavailable.
     expect([...filesystem.executionDurationByDay(unavailable).values()]).toEqual([60_000]);
     expect([...filesystem.canonicalRunCountByDay(unavailable).values()]).toEqual([2]);
     const unavailableInvocation = filesystem.viewPage("cost_monitor_agent_invocations", {
@@ -374,7 +368,7 @@ describe("SQLite dashboard read model multi-provider", () => {
     ] as const) {
       const row = filesystem.viewPage(view, { provider: "unavailable", model: "unavailable" })
         .rows[0];
-      expect(row).toMatchObject({ total_run_count: 2, total_tokens: 1_000, total_cost_brl: 500 });
+      expect(row).toMatchObject({ total_run_count: 1, total_tokens: 0, total_cost_brl: 0 });
     }
 
     filesystem.close();

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-rebuilds-disposable-snapshot-serves-zaip-records.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, readFile, utimes, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { afterEach, describe, expect, it, vi } from "vitest";
@@ -45,6 +45,16 @@ describe("SQLite dashboard read model", () => {
       ".agents/records/tasks/task.md",
     ]);
     filesystem.close();
+    // Delete only this test's owned projection tree; canonical inputs must survive.
+    await rm(join(root, ".local"), { recursive: true, force: true });
+    expect(await readFile(join(root, ".agents/records/tasks/task.md"), "utf8")).toBe("# task\n");
+    expect((await rebuildSqliteReadModel(root)).files).toBe(2);
+    const rebuilt = new SqliteReadModelFileSystem(root);
+    try {
+      await expect(rebuilt.readText(".agents/records/tasks/task.md")).resolves.toBe("# task\n");
+    } finally {
+      rebuilt.close();
+    }
   });
   it("serves canonical Task trace inputs without lifecycle manifests", async () => {
     const root = await createSqliteTestRoot();

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

@@ -7,7 +7,7 @@ export const dbRelativePath = ".local/sqlite/zaip-aios-dashboard.sqlite";
 // Schema 83 adds canonical priority, Run work type and reconciled macro stages.
 // Old snapshots must rebuild even when their canonical hashes still match.
 // Refresh persisted first-fold summaries after factual duration/coverage semantics change.
-export const readModelSchemaVersion = "85";
+export const readModelSchemaVersion = "86";
 export const requiredPersistedTables = [
   "zaip_aios_activities",
   "zaip_dim_llm_model",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-work-financial-summary.ts

@@ -0,0 +1,38 @@
+import type { DatabaseSync } from "node:sqlite";
+
+export type FinancialWorkItem = { kind: "task" | "spec" | "prd"; id: string };
+
+/** Union of factual Run identities, never a sum of overlapping card subtotals. */
+export function workFinancialSummary(database: DatabaseSync, items: readonly FinancialWorkItem[]) {
+  const row = database
+    .prepare(`WITH selected AS MATERIALIZED (
+      SELECT json_extract(value,'$.kind') kind,json_extract(value,'$.id') id FROM json_each(?)
+    ), matched AS MATERIALIZED (
+      SELECT a.* FROM activities a WHERE
+        EXISTS (SELECT 1 FROM selected s WHERE
+          (s.kind='task' AND s.id=a.task_id) OR
+          (s.kind='spec' AND s.id=a.spec_id) OR
+          (s.kind='prd' AND s.id=a.prd_id))
+        OR EXISTS (SELECT 1 FROM shared_creation_allocations allocation JOIN selected s
+          ON s.kind='spec' AND s.id=allocation.spec_id WHERE allocation.run_id=a.run_id)
+    )
+    SELECT COUNT(*) activity_count,COUNT(cost_brl) cost_known_count,
+      COUNT(*)-COUNT(cost_brl) cost_unknown_count,SUM(cost_brl) total_cost_brl,
+      SUM(total_tokens) total_tokens FROM matched`)
+    .get(JSON.stringify(items)) as Record<string, unknown>;
+  return {
+    ...row,
+    currency: "BRL",
+    semantics: "distinct_selected_work_activities",
+    period_basis: "selected_work_creation_date; lifetime_linked_runs",
+    item_count: new Set(items.map((item) => `${item.kind}:${item.id}`)).size,
+    note: "Custos dos itens incluem descendentes e não são aditivos. Este resumo conta cada Run vinculada uma vez; inclui a Run de origem integral quando uma SPEC possui alocação compartilhada. Custo indisponível não é zero.",
+  };
+}
+
+export function financialSnapshotMetadata(database: DatabaseSync) {
+  const row = database
+    .prepare("SELECT value FROM read_model_metadata WHERE key='snapshot_updated_at'")
+    .get() as { value?: string } | undefined;
+  return { snapshot_id: row?.value ?? null, snapshot_updated_at: row?.value ?? null };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/telemetry-reconciliation.integration.test.ts

@@ -0,0 +1,223 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import type { ServerType } from "@hono/node-server";
+import { serve } from "@hono/node-server";
+import type { Browser, Page } from "@playwright/test";
+import { loadWorkspaceLayout, WorkspaceFileSystem } from "@zaip-ai/core";
+import { findLatestCodexSegment } from "@zaip-ai/costs";
+import { afterEach, expect, it, vi } from "vitest";
+import { createV2Composition } from "../../../../../packages/cli/src/commands/v2-router.js";
+import { reconcileOrchestratorStop } from "../../../../../packages/cli/src/host-native-delegation/stop-closure.js";
+import { syncObservedRunManifest } from "../../../../../packages/cli/src/lifecycle-manifest-commands.js";
+import { LifecycleV2Gate } from "../../../../../packages/cli/src/lifecycle-v2.js";
+import { recordCodexTelemetryIfAvailable } from "../../../../../packages/cli/src/record-codex-telemetry.js";
+import { writeV2Config } from "../../../../../packages/cli/src/test-helpers.js";
+import { createDashboardApp } from "./server.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+const roots: string[] = [];
+afterEach(async () => {
+  vi.restoreAllMocks();
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+});
+
+it("recovers late exact telemetry after automatic stop, resumes failed persistence and projects once to ready", async () => {
+  const base = resolve(import.meta.dirname, "../../../../../.tmp/telemetry-integration");
+  await mkdir(base, { recursive: true });
+  const root = await mkdtemp(join(base, "fixture-"));
+  roots.push(root);
+  const filesystem = new WorkspaceFileSystem(root);
+  await writeV2Config(filesystem);
+  const layout = await loadWorkspaceLayout(filesystem);
+  const composition = createV2Composition(filesystem, layout);
+  const lifecycle = new LifecycleV2Gate(filesystem, layout, composition);
+  const start = (id: string, turn: string) =>
+    composition.runs.start({
+      id,
+      shortName: "telemetry-proof",
+      phase: "conversation",
+      runRole: "orchestrator",
+      runPurpose: "observation",
+      entrypoint: "observation",
+      workType: "new",
+      client: "codex",
+      agent: "agent-orchestrator",
+      model: "test-model",
+      provider: "openai",
+      requiresFinalizer: false,
+      clientThreadId: "11111111-1111-4111-8111-111111111111",
+      clientTurnId: turn,
+      conversationId: null,
+    });
+  const runId = "RUN-2026-10-19-01-00-LATE-TELEMETRY";
+  await start(runId, "turn-exact");
+  const activeId = "RUN-2026-10-19-01-01-ACTIVE-TELEMETRY";
+  await start(activeId, "turn-active");
+  await reconcileOrchestratorStop(await composition.runs.read(runId), composition, lifecycle);
+  const stopped = await composition.runs.read(runId);
+  expect(stopped.finished).not.toBeNull();
+  expect(stopped.effective_usage_records[0]?.tokens).toMatchObject({
+    total: null,
+    source: "unavailable",
+  });
+  await syncObservedRunManifest(runId, composition, filesystem);
+  await rebuildSqliteReadModel(root);
+  const snapshot = new SqliteReadModelFileSystem(root);
+  const app = createDashboardApp(
+    root,
+    "test-session",
+    resolve(import.meta.dirname, "../../../apps/frontend/dist"),
+    {
+      filesystem: snapshot,
+      canonicalFilesystem: filesystem,
+      layout,
+      snapshotReadOnly: true,
+      refreshReadModel: () => snapshot.rebuildAndRefresh(() => rebuildSqliteReadModel(root)),
+    },
+  );
+  const headers = { "x-zaip-session": "test-session" };
+  const ready = async () =>
+    (await app.request("/api/v2/ready", { headers })).json() as Promise<{
+      status: string;
+      snapshot_revision: string;
+      latest_token_collected_at: string | null;
+    }>;
+  let browser: Browser | undefined;
+  let page: Page | undefined;
+  let server: ServerType | undefined;
+  const browserErrors: string[] = [];
+  const browserMutations: string[] = [];
+  try {
+    const before = await ready();
+    expect(before.latest_token_collected_at).toBeNull();
+    // Explicit opt-in proof uses a real built frontend against this isolated
+    // production API. Normal unit runs do not acquire a browser or a port.
+    if (process.env.ZAIP_TELEMETRY_BROWSER_PROOF === "1") {
+      const url = await new Promise<string>((resolveUrl) => {
+        server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port: 0 }, ({ port }) =>
+          resolveUrl(`http://127.0.0.1:${port}`),
+        );
+      });
+      const { chromium } = await import("@playwright/test");
+      browser = await chromium.launch({ headless: true });
+      page = await browser.newPage();
+      page.on("pageerror", (error) => browserErrors.push(error.message));
+      page.on("request", (request) => {
+        if (request.method() === "POST") browserMutations.push(request.url());
+      });
+      await page.goto(`${url}/?token=test-session`);
+      await page.getByRole("button", { name: /^Operação/ }).click();
+      await page.locator(".operations-last-updated").waitFor({ state: "attached" });
+      expect(await page.locator(".operations-last-updated").innerText()).toMatch(
+        /Aguardando|Waiting/,
+      );
+    }
+    await mkdir(join(root, "host"));
+    const host = new WorkspaceFileSystem(join(root, "host"));
+    const sessionPath = "sessions/2026/10/19/rollout-11111111-1111-4111-8111-111111111111.jsonl";
+    const event = (type: string, extra: object, timestamp: string) => ({
+      type: "event_msg",
+      timestamp,
+      payload: { type, ...extra },
+    });
+    await host.writeTextAtomic(
+      sessionPath,
+      [
+        {
+          type: "session_meta",
+          payload: { id: "11111111-1111-4111-8111-111111111111", cwd: root },
+        },
+        event("task_started", { turn_id: "turn-exact" }, "2026-10-19T01:00:00.000Z"),
+        event(
+          "token_count",
+          {
+            info: {
+              last_token_usage: {
+                input_tokens: 100,
+                cached_input_tokens: 20,
+                output_tokens: 20,
+                reasoning_output_tokens: 5,
+                total_tokens: 120,
+              },
+              total_token_usage: {
+                input_tokens: 100,
+                cached_input_tokens: 20,
+                output_tokens: 20,
+                reasoning_output_tokens: 5,
+                total_tokens: 120,
+              },
+            },
+          },
+          "2026-10-19T01:00:01.000Z",
+        ),
+        event("task_complete", { turn_id: "turn-exact" }, "2026-10-19T01:00:02.000Z"),
+      ]
+        .map((value) => JSON.stringify(value))
+        .join("\n") + "\n",
+    );
+    const capture = async () =>
+      recordCodexTelemetryIfAvailable(
+        await composition.runs.read(runId),
+        composition,
+        filesystem,
+        null,
+        [],
+        (workspace, keys, options) =>
+          findLatestCodexSegment(workspace, keys, {
+            ...options,
+            sessionsRoot: host.root,
+            sessionPaths: [sessionPath],
+          }),
+      );
+    // Spool survives a write failure before the canonical usage correction.
+    const append = vi
+      .spyOn(composition.runs, "appendRecords")
+      .mockRejectedValueOnce(new Error("injected persistence interruption"));
+    await expect(capture()).rejects.toThrow("injected persistence interruption");
+    append.mockRestore();
+    await capture();
+    const recovered = await composition.runs.read(runId);
+    expect(recovered.finished).toEqual(stopped.finished);
+    expect(recovered.effective_usage_records).toHaveLength(1);
+    expect(recovered.effective_usage_records[0]?.tokens.total).toBe(120);
+    expect(recovered.effective_usage_records[0]?.cost.usd).toBeNull();
+    await Promise.all([capture(), capture()]);
+    await reconcileOrchestratorStop(await composition.runs.read(runId), composition, lifecycle);
+    expect((await composition.runs.read(runId)).records).toEqual(recovered.records);
+    expect((await composition.runs.read(activeId)).finished).toBeNull();
+    await syncObservedRunManifest(runId, composition, filesystem);
+    await app.request("/api/v2/refresh-projection", { method: "POST", headers });
+    const after = await ready();
+    expect(after.snapshot_revision).not.toBe(before.snapshot_revision);
+    expect(after.latest_token_collected_at).not.toBeNull();
+    expect(after.status).toBe("ready");
+    if (page) {
+      const observedPage = page;
+      await vi.waitFor(
+        async () =>
+          expect(await observedPage.locator(".operations-last-updated").innerText()).toMatch(
+            /Atualizado|Updated/,
+          ),
+        { timeout: 15000, interval: 200 },
+      );
+      expect(browserErrors).toEqual([]);
+      // Opening the app intentionally captures telemetry once. Passive
+      // observation never repeats capture or initiates reconciliation.
+      expect(browserMutations.map((url) => new URL(url).pathname)).toEqual([
+        "/api/v2/capture-telemetry",
+      ]);
+      await page.getByRole("button", { name: /^Monitor de Custos/ }).click();
+      await page.getByText("120", { exact: true }).first().waitFor();
+      const proofDir = resolve(import.meta.dirname, "../../../../../.local/maintenance-v65");
+      await mkdir(proofDir, { recursive: true });
+      await page.screenshot({ path: join(proofDir, "telemetry-dashboard.png"), fullPage: true });
+    }
+    await app.request("/api/v2/refresh-projection", { method: "POST", headers });
+    expect((await ready()).snapshot_revision).toBe(after.snapshot_revision);
+  } finally {
+    await browser?.close();
+    const startedServer = server;
+    if (startedServer) await new Promise<void>((done) => startedServer.close(() => done()));
+    snapshot.close();
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/work-priority-contract.test.ts

@@ -16,13 +16,13 @@ describe("work priority API contract", () => {
 
   it("writes priority without building a projection, while reads discard stale IDs", () => {
     const routes = readFileSync(new URL("server-operations-routes.ts", import.meta.url), "utf8");
-    const route = routes.slice(
-      routes.indexOf("app.put(`${API_PREFIX}/work-priority`"),
-      routes.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/board`'),
-    );
+    const route = readFileSync(new URL("server-work-priority-route.ts", import.meta.url), "utf8");
+    expect(routes).toContain('from "./server-work-priority-route.js"');
+    expect(routes).toContain("registerWorkPriorityRoute(app, dependencies)");
+    expect(route).toContain("app.put(`${API_PREFIX}/work-priority`");
     expect(route).not.toContain("buildCanonicalOperationsProjection");
     expect(route).not.toContain("knownWorkIds(");
-    expect(route).toContain("await canonicalFilesystem.writeTextAtomic(");
+    expect(route).toContain("await dependencies.canonicalFilesystem.writeTextAtomic(");
     expect(route).toContain("WORK_PRIORITY_PATH");
     expect(projectionSource).toMatch(/\[\s*\.\.\.new Set\(\s*input\.item_ids\.filter/);
     const read = projectionSource.slice(

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

@@ -1,11 +1,53 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
 import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { chromium } from "@playwright/test";
 import { describe, expect, it } from "vitest";
 import { host, startDashboardLaunchPage } from "./start-dashboard.mjs";
+import { createDashboardLaunchPage } from "./start-dashboard-launch-page.mjs";
+import { healthPath, runtimeKind } from "./start-dashboard-paths.mjs";
+
+async function repositoryLaunchPage(remote) {
+  const workspaceRoot = await mkdtemp(join(resolve(tmpdir()), "zaip-launch-page-test-"));
+  assert.equal(dirname(workspaceRoot), resolve(tmpdir()));
+  let page;
+  try {
+    execFileSync("git", ["init", "--quiet", workspaceRoot], { windowsHide: true });
+    if (remote)
+      execFileSync("git", ["-C", workspaceRoot, "remote", "add", "origin", remote], {
+        windowsHide: true,
+      });
+    page = await createDashboardLaunchPage({
+      port: 0,
+      host,
+      runtimeKind,
+      healthPath,
+      delay,
+      workspaceRoot,
+    });
+  } catch (error) {
+    await rm(workspaceRoot, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    ...page,
+    async close() {
+      try {
+        await page.close();
+      } finally {
+        await rm(workspaceRoot, { recursive: true, force: true });
+      }
+    },
+  };
+}
 
 describe("dashboard launch page", () => {
   it("serves an accessible active progress overlay and an automatic handoff while the runtime starts", async () => {
-    const launchPage = await startDashboardLaunchPage(0);
+    const launchPage = await repositoryLaunchPage("https://github.com/zaip-ai/zaip-aios.git");
     try {
       const page = await fetch(`http://${host}:${launchPage.port}/?token=temporary`);
       const health = await fetch(`http://${host}:${launchPage.port}/api/v2/health`);
@@ -62,12 +104,26 @@ describe("dashboard launch page", () => {
     }
   });
 
+  it.each([
+    null,
+    "/local/candidate.bundle",
+  ])("omits a GitHub badge for origin %s", async (remote) => {
+    const launchPage = await repositoryLaunchPage(remote);
+    try {
+      const page = await fetch(`http://${host}:${launchPage.port}/`);
+      expect(page.status).toBe(200);
+      expect(await page.text()).not.toContain('class="repository-badge"');
+    } finally {
+      await launchPage.close();
+    }
+  });
+
   it("keeps the handoff hidden until a real handoff target exists while progress polling continues", async () => {
     const launchPage = await startDashboardLaunchPage(0);
     let browser;
     let context;
     try {
-      browser = await chromium.launch();
+      browser = await chromium.launch({ chromiumSandbox: true });
       context = await browser.newContext();
       const page = await context.newPage();
       await page.route("**/api/v2/ready", (route) =>
@@ -131,7 +187,7 @@ describe("dashboard launch page", () => {
     let browser;
     let context;
     try {
-      browser = await chromium.launch();
+      browser = await chromium.launch({ chromiumSandbox: true });
       context = await browser.newContext();
       launchPage.setProgress({
         percent: 64,

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

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

package/templates/.agents/dashboard/packages/windows-launcher/Program.cs

@@ -261,7 +261,7 @@ namespace ZaipDashboardLauncher
                 // A missing workspace cannot have a project-local log yet.
                 var directory = diagnosticRoot == null
                     ? Path.Combine(Path.GetTempPath(), "zaip-dashboard-logs")
-                    : Path.Combine(diagnosticRoot, ".local", "dashboard-logs");
+                    : Path.Combine(diagnosticRoot, ".local", "temp", "dashboard-logs");
                 Directory.CreateDirectory(directory);
                 if (eventName == "executable_clicked")
                 {

package/templates/.agents/dashboard/packages/windows-launcher/build-dashboard-launcher.ps1

@@ -98,7 +98,7 @@ $compilerArguments = @("/nologo", "/target:winexe", "/out:$targetPath")
 if (Test-Path $resolvedIconPath) {
   $iconExtension = [System.IO.Path]::GetExtension($resolvedIconPath).ToLowerInvariant()
   if ($iconExtension -eq ".png") {
-    $generatedIconPath = Join-Path ([System.IO.Path]::GetTempPath()) "zaip-dashboard-icon.ico"
+    $generatedIconPath = Join-Path ([System.IO.Path]::GetTempPath()) ("zaip-dashboard-icon-" + [Guid]::NewGuid().ToString("N") + ".ico")
     Convert-PngToIco -PngPath $resolvedIconPath -IcoPath $generatedIconPath
     $compilerArguments += "/win32icon:$generatedIconPath"
   }

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

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

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

@@ -19,6 +19,7 @@ export default defineConfig({
   reporter: process.env.CI ? "github" : "list",
   use: {
     baseURL: `${baseURL}/?token=e2e-token`,
+    launchOptions: { chromiumSandbox: true },
     // 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",

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

@@ -1,6 +1,11 @@
 import { AxeBuilder } from "@axe-core/playwright";
-import { expect, type Locator, test } from "@playwright/test";
-import { selectWorkBoardType } from "./work-board-hydration.js";
+import { expect, test } from "@playwright/test";
+import {
+  boardItemCount,
+  selectOperations,
+  selectWorkBoardType,
+  waitForWorkBoardHydration,
+} from "./work-board-hydration.js";
 
 declare global {
   interface Window {
@@ -425,9 +430,11 @@ test("embeds traceability and keeps global settings and help available", async (
 });
 
 test("filters the all-work board into Tasks, SPECs and PRDs after hydration", async ({ page }) => {
+  const hydrated = waitForWorkBoardHydration(page, "all");
   await openDashboard(page);
   await selectPopulatedAllTime(page);
   await selectOperations(page);
+  await hydrated;
   const board = page.getByLabel("Kanban de trabalho");
   await expect(board.locator(".operations-task-card").first()).toBeVisible();
   const allItemCount = await boardItemCount(board);
@@ -548,8 +555,9 @@ test("shows the observed all-time macro duration consistently for SPEC and PRD",
       );
       await expect(top.locator(".operations-run-bar").first()).toHaveAttribute(
         "aria-label",
-        new RegExp(kind === "SPECs" ? "^SPEC " : "^PRD "),
+        new RegExp(kind === "SPECs" ? "^Abrir detalhes da SPEC " : "^Abrir detalhes da PRD "),
       );
+      await expect(top.locator(".operations-run-bar").first()).toHaveRole("button");
     }
   }
 });
@@ -655,11 +663,6 @@ function formatDashboardDuration(value: number): string {
   return `${Math.round(value / 1_000)} seg`;
 }
 
-async function boardItemCount(board: Locator): Promise<number> {
-  const counts = await board.locator(".operations-column-count").allTextContents();
-  return counts.reduce((total, value) => total + Number(value), 0);
-}
-
 test("uses canonical Kanban and paginated work-list views instead of obsolete entity tabs", async ({
   page,
 }) => {
@@ -743,13 +746,6 @@ async function selectPopulatedAllTime(page: import("@playwright/test").Page) {
   return response;
 }
 
-async function selectOperations(page: import("@playwright/test").Page) {
-  await page
-    .getByRole("navigation", { name: "Áreas do dashboard" })
-    .getByRole("button", { name: /Operação/ })
-    .click();
-}
-
 test("protects dashboard reads and rejects mutating methods", async ({ request }) => {
   const unauthorized = await request.get("/api/v2/operations");
   expect(unauthorized.status()).toBe(401);