@zaip-ai/cli 4.5.0 → 4.6.0

package/templates/.agents/dashboard/packages/local-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-local-runtime",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "private": true,
   "type": "module",
   "scripts": {

package/templates/.agents/dashboard/packages/local-runtime/scripts/test-sqlite-dashboard-startup.mjs

@@ -0,0 +1,233 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { createServer } from "node:net";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { setTimeout as delay } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
+
+// Exercises both built formats and the exact portable server entrypoint.
+// All fixtures and their single central database are cleaned after the test.
+const packageRoot = resolve(import.meta.dirname, "..");
+const checkout = resolve(packageRoot, "../../../..");
+const fixtures = resolve(checkout, ".local/sqlite/tests");
+const runtime = await import(pathToFileURL(resolve(packageRoot, "server.mjs")).href);
+const cjs = createRequire(import.meta.url)(resolve(packageRoot, "dist/server.cjs"));
+const budgetMs = 10_000;
+const taskContent = (title) =>
+  `---\nid: TASK-PORTABLE-STARTUP\ntitle: ${title}\nstatus: ready\nrisk: standard\ncreated_at: 2026-08-01T12:00:00.000Z\n---\n`;
+const previousDbPath = process.env.ZAIP_SQLITE_DB_PATH;
+delete process.env.ZAIP_SQLITE_DB_PATH;
+await mkdir(fixtures, { recursive: true });
+const workspace = await mkdtemp(resolve(fixtures, "portable-startup-"));
+const task = resolve(workspace, ".agents/records/tasks/task.md");
+const expectedPath = resolve(workspace, ".local/sqlite/zaip-aios-dashboard.sqlite");
+let child;
+
+function persistedTitle() {
+  const database = new DatabaseSync(expectedPath, { readOnly: true });
+  try {
+    return database
+      .prepare("SELECT content FROM zaip_vw_files WHERE path=?")
+      .get(".agents/records/tasks/task.md").content;
+  } finally {
+    database.close();
+  }
+}
+
+async function availablePort() {
+  const reservation = createServer();
+  reservation.listen(0, "127.0.0.1");
+  await once(reservation, "listening");
+  const port = reservation.address().port;
+  await new Promise((done, reject) =>
+    reservation.close((error) => (error ? reject(error) : done())),
+  );
+  return port;
+}
+
+async function stop() {
+  if (!child || child.exitCode !== null) return;
+  const exited = once(child, "exit");
+  child.kill();
+  await exited;
+  child = undefined;
+}
+
+async function launch(expectedCache, expectedTitle) {
+  const port = await availablePort();
+  const started = performance.now();
+  let stderr = "";
+  let spawnError;
+  child = spawn(process.execPath, [resolve(packageRoot, "server.mjs")], {
+    cwd: packageRoot,
+    env: {
+      ...process.env,
+      ZAIP_WORKSPACE: workspace,
+      ZAIP_SQLITE_DB_PATH: expectedPath,
+      ZAIP_SERVER_PORT: String(port),
+      ZAIP_UI_TOKEN: "portable-startup-fixture-token",
+      ZAIP_UI_ROOT: resolve(workspace, "ui"),
+      ZAIP_DASHBOARD_WATCH_SOURCES: "0",
+      ZAIP_DASHBOARD_LAUNCH_PROGRESS: "1",
+    },
+    stdio: ["ignore", "ignore", "pipe"],
+    windowsHide: true,
+  });
+  child.on("error", (error) => {
+    spawnError = error;
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-100_000);
+  });
+  const events = () =>
+    stderr.split(/\r?\n/).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  while (!events().some((event) => event.phase === "listening")) {
+    if (spawnError) throw spawnError;
+    assert.equal(child.exitCode, null, `Portable runtime exited before listening: ${stderr}`);
+    assert.ok(
+      performance.now() - started < budgetMs,
+      `Portable startup exceeded ${budgetMs}ms: ${stderr}`,
+    );
+    await delay(20);
+  }
+  const readModel = events().find((event) => event.event === "dashboard_sqlite_read_model");
+  assert.equal(readModel.cache, expectedCache);
+  if (expectedCache === "stale_seed") {
+    assert.equal(readModel.fingerprint_ms, 0);
+    assert.ok(!events().some((event) => event.phase === "source_fingerprint_started"));
+  }
+  const listeningMs = Math.round(performance.now() - started);
+  const url = `http://127.0.0.1:${port}/api/v2/health`;
+  const headers = { "x-zaip-session": "portable-startup-fixture-token" };
+  const response = await fetch(url, { headers, signal: AbortSignal.timeout(5_000) });
+  assert.equal(response.status, 200);
+  const health = await response.json();
+  assert.equal(health.status, "ok");
+  assert.ok(["updating", "current"].includes(health.snapshot_state));
+  const refreshStarted = performance.now();
+  let current = health;
+  while (current.snapshot_state !== "current") {
+    assert.ok(performance.now() - refreshStarted < 30_000, `Refresh did not complete: ${stderr}`);
+    await delay(30);
+    current = await (await fetch(url, { headers, signal: AbortSignal.timeout(5_000) })).json();
+  }
+  assert.equal(current.projection_refresh_failure, null);
+  assert.ok(persistedTitle().includes(expectedTitle));
+  const ready = await fetch(`http://127.0.0.1:${port}/api/v2/ready`, { headers });
+  assert.equal(ready.status, 200);
+  assert.equal((await ready.json()).storage_mode, "sqlite_read_model");
+  await stop();
+  return {
+    cache: readModel.cache,
+    fingerprint_ms: readModel.fingerprint_ms,
+    listening_ms: listeningMs,
+  };
+}
+
+try {
+  await mkdir(dirname(task), { recursive: true });
+  await mkdir(resolve(workspace, ".agents/config"), { recursive: true });
+  for (const filename of ["project.yaml", "framework.lock.yaml"]) {
+    await writeFile(
+      resolve(workspace, ".agents/config", filename),
+      await readFile(resolve(checkout, ".agents/config", filename)),
+    );
+  }
+  // Synthetic fixture manifests make lifecycle health meaningful for this
+  // isolated workspace; no real lifecycle records are modified by the harness.
+  const lifecycle = resolve(workspace, ".agents/records/lifecycle");
+  await mkdir(lifecycle, { recursive: true });
+  const updated_at = "2026-08-01T12:00:00.000Z";
+  await writeFile(
+    resolve(lifecycle, "manifest.json"),
+    JSON.stringify({
+      schema_version: 1,
+      updated_at,
+      offsets: {},
+    }),
+  );
+  await writeFile(
+    resolve(lifecycle, "summary.json"),
+    JSON.stringify({
+      schema_version: 1,
+      updated_at,
+      counts: { total: 1, by_kind: { task: 1 }, by_status: { ready: 1 } },
+      freshness: {},
+      usage: {},
+      periods: {},
+    }),
+  );
+  await mkdir(resolve(workspace, "ui"));
+  await writeFile(
+    resolve(workspace, "ui/index.html"),
+    "<!doctype html><title>Startup fixture</title>",
+  );
+  await writeFile(task, taskContent("Original portable seed"));
+  const built = await runtime.rebuildSqliteReadModel(workspace);
+  assert.equal(built.path, expectedPath);
+  await writeFile(task, taskContent("Changed before portable launch"));
+  for (const implementation of [runtime, cjs]) {
+    const seed = await implementation.prepareDashboardSqliteStartup(workspace);
+    assert.equal(seed.cache, "stale_seed");
+    assert.equal(seed.fingerprint_ms, 0);
+    assert.equal(seed.path, expectedPath);
+    assert.ok(persistedTitle().includes("Original portable seed"));
+  }
+  // Deterministically hold the refresh to prove the served seed remains updating.
+  let release;
+  const pending = new Promise((done) => {
+    release = done;
+  });
+  const filesystem = new runtime.SqliteReadModelFileSystem(workspace);
+  try {
+    const app = runtime.createDashboardApp(workspace, "fixture", resolve(workspace, "ui"), {
+      filesystem,
+      snapshotState: "updating",
+      refreshReadModel: () => pending,
+    });
+    const health = await app.request("/api/v2/health", {
+      headers: { "x-zaip-session": "fixture" },
+    });
+    assert.equal((await health.json()).snapshot_state, "updating");
+    release();
+    await pending;
+    await delay(0);
+  } finally {
+    filesystem.close();
+  }
+  const launches = [await launch("stale_seed", "Changed before portable launch")];
+  await writeFile(task, taskContent("Changed again before repeated launch"));
+  launches.push(await launch("stale_seed", "Changed again before repeated launch"));
+  const database = new DatabaseSync(expectedPath);
+  try {
+    database.exec("DROP INDEX zaip_activities_work_item_identity");
+  } finally {
+    database.close();
+  }
+  await writeFile(task, taskContent("Recovered invalid portable seed"));
+  launches.push(await launch("rebuilt", "Recovered invalid portable seed"));
+  const files = await readdir(dirname(expectedPath));
+  assert.deepEqual(
+    files.filter((file) => file.endsWith(".sqlite")),
+    ["zaip-aios-dashboard.sqlite"],
+  );
+  process.stdout.write(
+    `${JSON.stringify({ status: "passed", formats: ["portable-esm", "cjs"], launches })}\n`,
+  );
+} finally {
+  await stop();
+  await rm(workspace, { recursive: true, force: true });
+  if (previousDbPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+  else process.env.ZAIP_SQLITE_DB_PATH = previousDbPath;
+}

package/templates/.agents/dashboard/packages/local-runtime/scripts/validate-provider-nonzero.mjs

@@ -0,0 +1,45 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, realpathSync, symlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+// Exact-candidate validation can borrow installed dependencies while loading
+// the provider implementation and tests exclusively from this candidate.
+const dependencyRoot =
+  process.argv[2] ??
+  dirname(
+    resolve(
+      root,
+      execFileSync("git", ["rev-parse", "--git-common-dir"], {
+        cwd: root,
+        encoding: "utf8",
+        windowsHide: true,
+      }).trim(),
+    ),
+  );
+if (dependencyRoot) {
+  const installed = realpathSync(dependencyRoot);
+  for (const relative of [
+    "node_modules",
+    ".agents/dashboard/packages/local-runtime/node_modules",
+  ]) {
+    const destination = resolve(root, relative);
+    const source = resolve(installed, relative);
+    if (!existsSync(source)) throw new Error(`Missing installed dependencies: ${relative}`);
+    if (!existsSync(destination)) symlinkSync(source, destination, "junction");
+  }
+}
+const require = createRequire(resolve(root, "package.json"));
+const result = spawnSync(
+  process.execPath,
+  [
+    resolve(dirname(require.resolve("vitest/package.json")), "vitest.mjs"),
+    "run",
+    ".agents/dashboard/packages/local-runtime/src/sqlite-provider-nonzero.test.ts",
+    "--no-file-parallelism",
+  ],
+  { cwd: root, stdio: "inherit", shell: false, windowsHide: true },
+);
+if (result.error) throw result.error;
+process.exitCode = result.status ?? 1;

package/templates/.agents/dashboard/packages/local-runtime/scripts/verify-dashboard-executable-startup.mjs

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { dashboardUrl, readDashboardSession } from "../start-dashboard.mjs";
+import { launcherLogPath, workspaceRoot } from "../start-dashboard-paths.mjs";
+
+assert.equal(
+  process.platform,
+  "win32",
+  "This verification exercises the actual Windows executable",
+);
+const executable = resolve(workspaceRoot, ".agents/dashboard/zaip-dashboard-windows.exe");
+const results = [];
+for (let click = 1; click <= 3; click += 1) {
+  const previous = await readDashboardSession();
+  const startedAt = Date.now();
+  const child = spawn(executable, [], { cwd: workspaceRoot, windowsHide: true, stdio: "ignore" });
+  let launchError = null;
+  child.on("error", (error) => {
+    launchError = error;
+  });
+  let session = null;
+  let health = null;
+  while (Date.now() - startedAt < 30_000) {
+    if (launchError) throw launchError;
+    const candidate = await readDashboardSession();
+    if (candidate && candidate.serverPid !== previous?.serverPid) {
+      const url = dashboardUrl(candidate.port, candidate.token);
+      try {
+        const response = await fetch(new URL("/api/v2/health", url), {
+          signal: AbortSignal.timeout(1_000),
+        });
+        if (response.ok) {
+          health = await response.json();
+          const page = await fetch(url, { signal: AbortSignal.timeout(1_000) });
+          if (page.ok && (await page.text()).includes("<html")) {
+            session = candidate;
+            break;
+          }
+        }
+      } catch {
+        /* Poll only this workspace's newly created runtime. */
+      }
+    }
+    await delay(100);
+  }
+  assert.ok(session, `Click ${click} did not serve a new healthy dashboard within 30s`);
+  const elapsedMs = Date.now() - startedAt;
+  const log = await readFile(launcherLogPath, "utf8");
+  const phases = log
+    .split(/\r?\n/)
+    .flatMap((line) => {
+      const offset = line.indexOf('{"event":"dashboard_sqlite_phase"');
+      if (offset < 0) return [];
+      try {
+        return [JSON.parse(line.slice(offset))];
+      } catch {
+        return [];
+      }
+    })
+    .filter((phase) => phase.launcher_pid === session.rootPid);
+  assert.equal(health.workspace, workspaceRoot);
+  assert.equal(health.server_pid, session.serverPid);
+  assert.equal(health.storage.storage_mode, "sqlite_read_model");
+  assert.equal(health.projection_refresh_failure, null);
+  // Capture diagnostics are preserved in the evidence. Serving availability
+  // is independently verified against the exact new executable session.
+  const readModelEvent = log
+    .split(/\r?\n/)
+    .flatMap((line) => {
+      const offset = line.indexOf('{"event":"dashboard_sqlite_read_model"');
+      if (offset < 0) return [];
+      try {
+        return [JSON.parse(line.slice(offset))];
+      } catch {
+        return [];
+      }
+    })
+    .at(-1);
+  assert.equal(readModelEvent?.cache, "stale_seed");
+  assert.equal(readModelEvent?.fingerprint_ms, 0);
+  assert.ok(phases.some((phase) => phase.phase === "handoff_complete"));
+  const result = {
+    click,
+    elapsed_ms: elapsedMs,
+    pid: session.serverPid,
+    port: session.port,
+    health,
+    read_model: readModelEvent,
+    phases,
+  };
+  results.push(result);
+  console.log(JSON.stringify(result));
+  assert.ok(elapsedMs < 10_000, `Click ${click}: ${elapsedMs}ms exceeds the 10s warm-start budget`);
+  await delay(500);
+}
+const evidenceDirectory = resolve(workspaceRoot, ".local/evidences/dashboard-startup");
+await mkdir(evidenceDirectory, { recursive: true });
+await writeFile(
+  resolve(evidenceDirectory, "executable-startup.json"),
+  JSON.stringify({ executable, observed_at: new Date().toISOString(), results }, null, 2) + "\n",
+);
+console.log(
+  "PASS: three actual executable launches served the validated SQLite model and HTML within 10s each.",
+);

package/templates/.agents/dashboard/packages/local-runtime/scripts/verify-dashboard-reconciliation-executable.mjs

@@ -0,0 +1,271 @@
+import assert from "node:assert/strict";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { stopProcessTree } from "../start-dashboard-processes.mjs";
+
+if (process.platform !== "win32") {
+  console.log("Windows executable proof unavailable on this host; browser regression is separate.");
+  process.exit(0);
+}
+const checkout = resolve(import.meta.dirname, "../../../../..");
+const packageRoot = resolve(import.meta.dirname, "..");
+const common = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+  cwd: checkout,
+  encoding: "utf8",
+  windowsHide: true,
+}).trim();
+const canonicalRoot = dirname(resolve(checkout, common));
+const evidence = resolve(
+  process.env.ZAIP_DASHBOARD_PROOF_DIR ??
+    join(checkout, ".local/evidences/dashboard-reconciliation"),
+);
+assert.ok(
+  [checkout, canonicalRoot].some((root) => {
+    const local = relative(join(root, ".local"), evidence);
+    return (
+      !isAbsolute(local) &&
+      local !== ".." &&
+      !local.startsWith(".." + (process.platform === "win32" ? "\\" : "/"))
+    );
+  }),
+  "Proof destination must stay inside this checkout or canonical repository .local",
+);
+const compile = spawnSync(
+  "powershell",
+  [
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    resolve(checkout, ".agents/dashboard/packages/windows-launcher/build-dashboard-launcher.ps1"),
+    "-SkipReleaseSync",
+  ],
+  { cwd: checkout, stdio: "inherit", windowsHide: true },
+);
+assert.equal(compile.status, 0);
+const base = join(checkout, ".tmp", "reconcile-exe");
+await mkdir(base, { recursive: true });
+const fixture = await mkdtemp(join(base, "f-"));
+const fixtureRuntime = join(fixture, ".agents/dashboard/packages/local-runtime");
+const key = createHash("sha256")
+  .update(fixture + ":dashboard-sqlite")
+  .digest("hex")
+  .slice(0, 16);
+const sessionPath = join(
+  tmpdir(),
+  "zaip-aios",
+  "dashboard-sqlite-" + key,
+  "dashboard-sqlite-session.json",
+);
+const require = createRequire(resolve(checkout, "package.json"));
+const { chromium } = require("@playwright/test");
+let session;
+let native;
+let browser;
+let verifiedFixtureSession = false;
+try {
+  await mkdir(fixtureRuntime, { recursive: true });
+  for (const file of (await readdir(packageRoot)).filter((name) => name.endsWith(".mjs")))
+    await cp(join(packageRoot, file), join(fixtureRuntime, file));
+  await mkdir(join(fixtureRuntime, "scripts"), { recursive: true });
+  await cp(
+    join(packageRoot, "scripts/rebuild-sqlite-read-model.mjs"),
+    join(fixtureRuntime, "scripts/rebuild-sqlite-read-model.mjs"),
+  );
+  await cp(
+    resolve(checkout, ".agents/dashboard/zaip-dashboard-windows.exe"),
+    join(fixture, ".agents/dashboard/zaip-dashboard-windows.exe"),
+  );
+  await cp(
+    resolve(checkout, ".agents/dashboard/apps/frontend/dist"),
+    join(fixture, ".agents/dashboard/apps/frontend/dist"),
+    { recursive: true },
+  );
+  await mkdir(join(fixture, ".agents/config"), { recursive: true });
+  for (const file of ["project.yaml", "framework.lock.yaml"])
+    await cp(join(checkout, ".agents/config", file), join(fixture, ".agents/config", file));
+  const lifecycle = join(fixture, ".agents/records/lifecycle");
+  await mkdir(lifecycle, { recursive: true });
+  const updated_at = "2026-09-29T10:00:00Z";
+  await writeFile(
+    join(lifecycle, "manifest.json"),
+    JSON.stringify({ schema_version: 1, updated_at, offsets: {} }),
+  );
+  await writeFile(
+    join(lifecycle, "summary.json"),
+    JSON.stringify({
+      schema_version: 1,
+      updated_at,
+      counts: { total: 0, by_kind: {}, by_status: {} },
+      freshness: {},
+      usage: {},
+      periods: {},
+    }),
+  );
+  await mkdir(join(fixture, ".agents/runtime/bin"), { recursive: true });
+  // Production subprocess boundary and RunV2Fold shape; only fixture records change.
+  await writeFile(
+    join(fixture, ".agents/runtime/bin/zaip.mjs"),
+    [
+      'import { mkdirSync, writeFileSync } from "node:fs";',
+      'mkdirSync(".agents/records/tasks", {recursive:true});',
+      'writeFileSync(".agents/records/tasks/TASK-FIXTURE.md", "---\\nschema_version: 2\\nid: TASK-FIXTURE\\ntitle: Fixture orphan\\nstatus: blocked\\ncreated_at: 2026-09-29T10:00:00Z\\n---\\n");',
+      'const reason = "Explicit orphan reconciliation found no active host invocation or terminal work outcome; repair is required before resuming (Run RUN-FIXTURE).";',
+      'process.stderr.write("fixture CLI diagnostic\\n");',
+      'process.stdout.write(JSON.stringify({ runs:[{run:{run_id:"RUN-FIXTURE"},status:"failed",finished:{status:"failed",summary:"Host stopped"}}],',
+      'reconciliations:[{status:"closed",tasks:[{id:"TASK-FIXTURE",status:"blocked",status_reason:reason}], changes:[{id:"CHG-FIXTURE",status:"blocked",status_reason:reason}], executions:[{id:"EXEC-FIXTURE",status:"blocked",status_reason:reason}]}] }));',
+    ].join("\n"),
+  );
+  native = spawn(join(fixture, ".agents/dashboard/zaip-dashboard-windows.exe"), [], {
+    cwd: fixture,
+    windowsHide: true,
+    stdio: "ignore",
+    env: { ...process.env, ZAIP_UI_NO_BROWSER: "1", ZAIP_DASHBOARD_WATCH_SOURCES: "0" },
+  });
+  const started = Date.now();
+  while (Date.now() - started < 45_000) {
+    try {
+      session = JSON.parse(await readFile(sessionPath, "utf8"));
+      if (session?.serverPid) {
+        const response = await fetch("http://127.0.0.1:" + session.port + "/api/v2/health");
+        if (response.ok) {
+          const health = await response.json();
+          assert.equal(health.workspace, fixture);
+          assert.equal(health.workspaceKey, key);
+          assert.equal(health.server_pid, session.serverPid);
+          verifiedFixtureSession = true;
+          break;
+        }
+      }
+    } catch {
+      /* Wait for this fixture's executable session only. */
+    }
+    await delay(100);
+  }
+  assert.ok(session?.serverPid, "Executable did not publish a healthy fixture session");
+  assert.ok(verifiedFixtureSession, "Fixture process ownership was not verified");
+  browser = await chromium.launch({ headless: true });
+  const page = await browser.newPage();
+  const errors = [];
+  page.on("pageerror", (error) => errors.push(error.message));
+  await page.goto(
+    "http://127.0.0.1:" + session.port + "/?token=" + encodeURIComponent(session.token),
+  );
+  await page
+    .locator(".dashboard-header-brand small")
+    .filter({ hasText: "Última Atualização" })
+    .waitFor();
+  assert.equal(await page.locator(".dashboard-header-brand small").count(), 1);
+  await page.getByRole("button", { name: "Atualizar", exact: true }).first().click();
+  const responsePromise = page.waitForResponse(
+    (response) =>
+      response.url().includes("/api/v2/reconcile-open-work") &&
+      response.request().method() === "POST",
+  );
+  await page.getByRole("button", { name: "Reconciliar itens abertos", exact: true }).click();
+  const response = await responsePromise;
+  assert.equal(response.status(), 200);
+  const receipt = await response.json();
+  assert.equal(receipt.reconciliation.reconciled_ids.length, 4);
+  assert.equal(receipt.reconciliation.blocked.length, 3);
+  await page.getByRole("button", { name: "Veja mais" }).click();
+  const dialog = page.getByRole("dialog", { name: "Resultado da reconciliação manual" });
+  await dialog.waitFor();
+  assert.ok((await dialog.textContent()).includes("Falha técnica"));
+  assert.ok((await dialog.textContent()).includes("Outros estados registrados (1)"));
+  assert.ok((await dialog.textContent()).includes("Desfechos bloqueados (3)"));
+  assert.equal(await dialog.locator("code").filter({ hasText: "TASK-FIXTURE" }).count(), 1);
+  assert.ok((await dialog.textContent()).includes("sem novos tokens não altera esse horário"));
+  assert.deepEqual(errors, []);
+  const directory = join(fixture, ".local/dashboard-logs");
+  let events = [];
+  for (let attempt = 0; attempt < 100; attempt++) {
+    events = (
+      await Promise.all(
+        (
+          await readdir(directory)
+        )
+          .filter((name) => name.endsWith(".jsonl"))
+          .map((name) => readFile(join(directory, name), "utf8")),
+      )
+    )
+      .join("")
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+    if (
+      events.some(
+        (event) =>
+          event.event === "projection_refresh_completed" &&
+          event.job_id === receipt.reconciliation.diagnostics.job_id,
+      )
+    )
+      break;
+    await delay(50);
+  }
+  for (const event of [
+    "executable_clicked",
+    "node_started",
+    "launcher_entered",
+    "runtime_app_started",
+    "reconciliation_button_received",
+    "cli_output",
+    "reconciliation_completed",
+    "projection_refresh_completed",
+  ])
+    assert.ok(
+      events.some((item) => item.event === event),
+      "Missing persisted event " + event,
+    );
+  const launchId = events.find((event) => event.event === "executable_clicked").correlation_id;
+  for (const component of ["native", "launcher", "runtime"])
+    assert.ok(
+      events.some((event) => event.component === component && event.correlation_id === launchId),
+    );
+  assert.ok(!JSON.stringify(events).includes(session.token));
+  await mkdir(evidence, { recursive: true });
+  await page.screenshot({ path: join(evidence, "reconciliation-executable.png"), fullPage: true });
+  await writeFile(
+    join(evidence, "executable-browser.json"),
+    JSON.stringify(
+      {
+        observed_at: new Date().toISOString(),
+        fixture_only: true,
+        native_exit_code: native.exitCode,
+        receipt,
+        events,
+        browser_errors: errors,
+      },
+      null,
+      2,
+    ),
+  );
+  console.log(
+    JSON.stringify({
+      status: "passed",
+      executable: "actual Windows EXE",
+      fixture_only: true,
+      persisted_events: events.length,
+      job_id: receipt.reconciliation.diagnostics.job_id,
+      proof_directory: evidence,
+    }),
+  );
+} finally {
+  await browser?.close();
+  if (verifiedFixtureSession && session?.rootPid) await stopProcessTree(session.rootPid);
+  if (native && native.exitCode === null) await stopProcessTree(native.pid);
+  const fixtureRelative = relative(resolve(base), resolve(fixture));
+  assert.ok(
+    fixtureRelative &&
+      !isAbsolute(fixtureRelative) &&
+      fixtureRelative !== ".." &&
+      !fixtureRelative.startsWith(".." + (process.platform === "win32" ? "\\" : "/")),
+    "Recursive cleanup must stay below the resolved fixture base",
+  );
+  await rm(resolve(fixture), { recursive: true, force: true });
+}