@zaip-ai/cli 4.5.0 → 4.6.0

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

@@ -42,16 +42,10 @@ export async function rebuildSqliteReadModel(
   options: SqliteRebuildOptions = {},
 ): Promise<SqliteRebuildResult> {
   const path = sqliteReadModelPath(workspaceRoot);
-  // Reuse only when schema and canonical fingerprint still match; otherwise rebuild.
+  // Startup serves a validated generation; the worker verifies canonical freshness.
   if (options.preferExisting && !options.forceCanonical) {
     try {
-      validateSqliteReadModelSchema(path);
-      const fingerprintStartedAt = performance.now();
-      const sourceSnapshot = await sourceFingerprint(
-        workspaceRoot,
-        rebuildFingerprintOptions(path, options),
-      );
-      const fingerprint = `${sourceSnapshot.fingerprint}\ncurrent_day=${saoPauloDay(new Date().toISOString())}`;
+      validateSqliteReadModelSchema(path, { integrity: "quick" });
       const database = new DatabaseSync(path, { readOnly: true });
       try {
         if (hasReusableSnapshotPayloads(database)) {
@@ -60,38 +54,18 @@ export async function rebuildSqliteReadModel(
               "SELECT value FROM zaip_vw_read_model_metadata WHERE key = 'source_file_count'",
             )
             .get() as { value: string };
-          const files = readSnapshotFileCount(
-            path,
-            fingerprint,
-            readModelSchemaVersion,
-            hasReusableSnapshotPayloads,
-          );
-          if (files !== null) {
-            return {
-              files,
-              path,
-              cache: "generation",
-              fingerprint_ms: Math.round(performance.now() - fingerprintStartedAt),
-              materialize_ms: 0,
-              refresh: {
-                reused_sources: sourceSnapshot.reusedFiles,
-                processed_sources: sourceSnapshot.hashedFiles,
-                added_sources: 0,
-                changed_sources: 0,
-                removed_sources: 0,
-                canonical_runs_refolded: 0,
-              },
-            };
-          }
+          const files = Number(row?.value);
+          if (!Number.isSafeInteger(files) || files < 0)
+            throw new Error("Invalid snapshot file count");
           return {
-            files: Number(row.value),
+            files,
             path,
             cache: "stale_seed",
-            fingerprint_ms: Math.round(performance.now() - fingerprintStartedAt),
+            fingerprint_ms: 0,
             materialize_ms: 0,
             refresh: {
-              reused_sources: sourceSnapshot.reusedFiles,
-              processed_sources: sourceSnapshot.hashedFiles,
+              reused_sources: 0,
+              processed_sources: 0,
               added_sources: 0,
               changed_sources: 0,
               removed_sources: 0,

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

@@ -122,7 +122,10 @@ export function persistedSourceCheckpoint(
  * is intentionally independent of source fingerprints: a matching cache key
  * is not evidence that a partially copied or old-schema file is safe.
  */
-export function validateSqliteReadModelSchema(path: string): {
+export function validateSqliteReadModelSchema(
+  path: string,
+  options: { integrity?: "full" | "quick" } = {},
+): {
   schemaVersion: string;
   tableCount: number;
   viewCount: number;
@@ -130,13 +133,12 @@ export function validateSqliteReadModelSchema(path: string): {
 } {
   const database = new DatabaseSync(path, { readOnly: true });
   try {
-    const integrity = database.prepare("PRAGMA integrity_check").get() as {
-      integrity_check?: string;
-    };
-    if (integrity.integrity_check !== "ok")
-      throw new Error(
-        `SQLite integrity check failed for ${path}: ${integrity.integrity_check ?? "unknown"}`,
-      );
+    // Only startup opts into quick_check. Workers and qualification retain the
+    // full cross-index integrity check, independently of source cache reuse.
+    const pragma = options.integrity === "quick" ? "quick_check" : "integrity_check";
+    const integrity = database.prepare(`PRAGMA ${pragma}`).get() as Record<string, unknown>;
+    if (integrity[pragma] !== "ok")
+      throw new Error(`SQLite ${pragma} failed for ${path}: ${integrity[pragma] ?? "unknown"}`);
     const objects = database
       .prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view', 'index')")
       .all() as Array<{ name: string; type: "table" | "view" | "index" }>;

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

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
+import { CanonicalSourceRevisionCache } from "./canonical-source-revision-cache.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -87,23 +88,9 @@ export function isCodexManagedWorktreeRoot(root: string): boolean {
   return /[\\/]\.codex[\\/]worktrees(?:[\\/][^\\/]+){1,2}$/iu.test(root);
 }
 
-function canonicalRevision(content: string, source: string): [string, number, number] {
-  if (source.endsWith(".jsonl")) {
-    const dates = [...content.matchAll(/"occurred_at"\s*:\s*"([^"]+)"/gu)];
-    return [
-      dates.reduce((latest, match) => ((match[1] ?? "") > latest ? (match[1] ?? "") : latest), ""),
-      dates.length,
-      content.length,
-    ];
-  }
-  const updated = /^updated_at:\s*([^\r\n]+)/mu.exec(content)?.[1]?.trim() ?? "";
-  const created = /^created_at:\s*([^\r\n]+)/mu.exec(content)?.[1]?.trim() ?? "";
-  const revision = Number(/^revision:\s*(\d+)/mu.exec(content)?.[1] ?? 0);
-  return [updated || created, revision, content.length];
-}
-
 async function selectCanonicalSources(
   roots: readonly string[],
+  cache: CanonicalSourceRevisionCache,
 ): Promise<Array<{ path: string; source: string }>> {
   const locations = new Map<string, string[]>();
   for (const [index, root] of roots.entries()) {
@@ -149,36 +136,37 @@ async function selectCanonicalSources(
   const entries = [...locations.entries()];
   for (let offset = 0; offset < entries.length; offset += 32) {
     selected.push(
-      ...(await Promise.all(
-        entries.slice(offset, offset + 32).map(async ([source, paths]) => {
-          const firstPath = paths[0];
-          if (firstPath === undefined) throw new Error(`No canonical source for ${source}`);
-          if (paths.length === 1) return { source, path: firstPath };
-          // Worktree checkout mtimes do not represent canonical record recency.
-          // Compare embedded revision timestamps and prefer the first registered
-          // source on an exact tie, so repeated scans remain deterministic.
-          const revisions = await Promise.all(
-            paths.map(async (path) => canonicalRevision(await readFile(path, "utf8"), source)),
-          );
-          let winner = 0;
-          for (let index = 1; index < paths.length; index += 1) {
-            const left = revisions[index];
-            const right = revisions[winner];
-            if (left === undefined || right === undefined)
-              throw new Error(`Incomplete canonical revisions for ${source}`);
-            if (
-              left[0] > right[0] ||
-              (left[0] === right[0] &&
-                (left[1] > right[1] || (left[1] === right[1] && left[2] > right[2])))
-            )
-              winner = index;
-          }
-          const selectedPath = paths[winner];
-          if (selectedPath === undefined)
-            throw new Error(`No selected canonical source for ${source}`);
-          return { source, path: selectedPath };
-        }),
-      )),
+      ...(
+        await Promise.all(
+          entries.slice(offset, offset + 32).map(async ([source, paths]) => {
+            const firstPath = paths[0];
+            if (firstPath === undefined) throw new Error(`No canonical source for ${source}`);
+            if (paths.length === 1) return { source, path: firstPath };
+            // Worktree checkout mtimes do not represent canonical record recency.
+            // Compare embedded revision timestamps and prefer the first registered
+            // source on an exact tie, so repeated scans remain deterministic.
+            const revisions = await Promise.all(paths.map((path) => cache.read(path, source)));
+            let winner = revisions.findIndex((item) => item !== null);
+            if (winner < 0) return null;
+            for (let index = 1; index < paths.length; index += 1) {
+              const left = revisions[index]?.entry.revision;
+              const right = revisions[winner]?.entry.revision;
+              if (!left) continue;
+              if (!right) throw new Error(`Incomplete canonical revisions for ${source}`);
+              if (
+                left[0] > right[0] ||
+                (left[0] === right[0] &&
+                  (left[1] > right[1] || (left[1] === right[1] && left[2] > right[2])))
+              )
+                winner = index;
+            }
+            const selectedPath = paths[winner];
+            if (selectedPath === undefined)
+              throw new Error(`No selected canonical source for ${source}`);
+            return { source, path: selectedPath };
+          }),
+        )
+      ).filter((item): item is { source: string; path: string } => item !== null),
     );
   }
   return selected.sort((left, right) => left.source.localeCompare(right.source));
@@ -192,9 +180,16 @@ export async function sourceFingerprint(
   candidates: SqliteReadModelSourceCandidate[];
   hashedFiles: number;
   reusedFiles: number;
+  duplicateReads: number;
+  duplicateReused: number;
 }> {
+  const revisionCache = await CanonicalSourceRevisionCache.open(
+    workspaceRoot,
+    options.verifyContent,
+  );
   const candidates = await selectCanonicalSources(
     options.sourceRoots ?? (await dashboardCanonicalSourceRoots(workspaceRoot)),
+    revisionCache,
   );
   const candidatesWithMetadata: SqliteReadModelSourceCandidate[] = [];
   let hashedFiles = 0;
@@ -261,6 +256,7 @@ export async function sourceFingerprint(
       ).filter((candidate): candidate is SqliteReadModelSourceCandidate => candidate !== null),
     );
   }
+  await revisionCache.persist();
   return {
     fingerprint: candidatesWithMetadata
       .map(
@@ -271,6 +267,8 @@ export async function sourceFingerprint(
     candidates: candidatesWithMetadata,
     hashedFiles,
     reusedFiles,
+    duplicateReads: revisionCache.reads,
+    duplicateReused: revisionCache.reused,
   };
 }
 

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

@@ -23,13 +23,7 @@ async function createSqliteTestRoot(): Promise<string> {
 afterEach(async () => {
   vi.useRealTimers();
   vi.restoreAllMocks();
-  await Promise.all(
-    roots
-      .splice(0)
-      .map((root) =>
-        import("node:fs/promises").then(({ rm }) => rm(root, { recursive: true, force: true })),
-      ),
-  );
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 describe("SQLite dashboard read model", () => {
   it("materializes a fresh workspace without opening a nonexistent checkpoint database", async () => {
@@ -87,7 +81,7 @@ describe("SQLite dashboard read model", () => {
       filesystem.close();
     }
   });
-  it("reuses an unchanged verified fingerprint as the current generation", async () => {
+  it("serves an unchanged validated snapshot as a stale seed pending canonical verification", async () => {
     const root = await createSqliteTestRoot();
     roots.push(root);
     await mkdir(join(root, ".agents/config"), { recursive: true });
@@ -95,7 +89,9 @@ describe("SQLite dashboard read model", () => {
     vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     await rebuildSqliteReadModel(root);
     await expect(rebuildSqliteReadModel(root, { preferExisting: true })).resolves.toMatchObject({
-      cache: "generation",
+      cache: "stale_seed",
+      fingerprint_ms: 0,
+      materialize_ms: 0,
     });
   });
   it("rolls back a failed refresh including first-fold payloads while a reader remains open", async () => {

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

@@ -9,7 +9,11 @@ export type {
   SqliteFirstFoldMonthlyQuick,
 } from "./sqlite-read-model-first-fold-types.js";
 export { rebuildSqliteReadModel } from "./sqlite-read-model-rebuild.js";
-export { sqliteReadModelPath, validateSqliteReadModelSchema } from "./sqlite-read-model-schema.js";
+export {
+  hasReusableSnapshotPayloads,
+  sqliteReadModelPath,
+  validateSqliteReadModelSchema,
+} from "./sqlite-read-model-schema.js";
 export {
   type SqliteReadModelSourceCandidate,
   sourceFingerprint,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-startup-seed.test.ts

@@ -0,0 +1,87 @@
+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, vi } from "vitest";
+import { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
+import { rebuildSqliteReadModel } from "./sqlite-read-model-rebuild.js";
+import { validateSqliteReadModelSchema } from "./sqlite-read-model-schema.js";
+import * as fingerprints from "./sqlite-read-model-source-fingerprint.js";
+
+const roots: string[] = [];
+const source = ".agents/records/tasks/TASK-STARTUP.md";
+const record = (title: string) =>
+  `---\nid: TASK-STARTUP\ntitle: ${title}\nstatus: executing\ncreated_at: 2026-09-29T12:00:00Z\n---\n`;
+async function fixture() {
+  const parent = resolve(import.meta.dirname, "../../../../..", ".local/sqlite/tests");
+  await mkdir(parent, { recursive: true });
+  const root = await mkdtemp(join(parent, "startup-seed-"));
+  roots.push(root);
+  await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+  await writeFile(join(root, source), record("Before"));
+  return root;
+}
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+describe("validated startup generation", () => {
+  it("serves a seed without traversing sources, then canonical refresh observes the changed record", async () => {
+    const root = await fixture();
+    await rebuildSqliteReadModel(root);
+    await writeFile(join(root, source), record("After"));
+    const fingerprint = vi.spyOn(fingerprints, "sourceFingerprint");
+    const sql = vi.spyOn(DatabaseSync.prototype, "prepare");
+    const result = await rebuildSqliteReadModel(root, {
+      preferExisting: true,
+      sourceRoots: ["invalid-startup-root"],
+    });
+    expect(result).toMatchObject({ cache: "stale_seed", fingerprint_ms: 0, materialize_ms: 0 });
+    expect(fingerprint).not.toHaveBeenCalled();
+    expect(sql).toHaveBeenCalledWith("PRAGMA quick_check");
+    expect(sql).not.toHaveBeenCalledWith("PRAGMA integrity_check");
+    const reader = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await reader.readText(source)).toContain("title: Before");
+      await rebuildSqliteReadModel(root);
+      expect(sql).toHaveBeenCalledWith("PRAGMA integrity_check");
+      reader.refresh();
+      expect(await reader.readText(source)).toContain("title: After");
+    } finally {
+      reader.close();
+    }
+  });
+
+  it.each([
+    "old-schema",
+    "missing-index",
+    "missing-payload",
+  ])("rebuilds %s rather than serving incomplete seed", async (damage) => {
+    const root = await fixture();
+    const first = await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(first.path);
+    try {
+      if (damage === "old-schema")
+        database.exec(
+          "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json,'$.value','0') WHERE payload_type='metadata' AND json_extract(payload_json,'$.key')='schema_version'",
+        );
+      else if (damage === "missing-index")
+        database.exec("DROP INDEX zaip_activities_work_item_identity");
+      else
+        database.exec(
+          "DELETE FROM zaip_aios_activities WHERE payload_type='first_fold_all_time_board_cache'",
+        );
+    } finally {
+      database.close();
+    }
+    expect((await rebuildSqliteReadModel(root, { preferExisting: true })).cache).toBe("rebuilt");
+    expect(() => validateSqliteReadModelSchema(first.path)).not.toThrow();
+  });
+
+  it("rejects corrupt bytes and never serves them as a validated seed", async () => {
+    const root = await fixture();
+    const first = await rebuildSqliteReadModel(root);
+    await writeFile(first.path, "corrupt SQLite bytes");
+    expect(() => validateSqliteReadModelSchema(first.path, { integrity: "quick" })).toThrow();
+    await expect(rebuildSqliteReadModel(root, { preferExisting: true })).rejects.toThrow();
+  });
+});

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

@@ -1,11 +1,15 @@
 import { appendFileSync, mkdirSync } from "node:fs";
-import { launcherLogPath, sessionDirectory } from "./start-dashboard-paths.mjs";
+import { createDashboardDiagnostics, sanitizeDiagnostic } from "./dashboard-diagnostics.mjs";
+import { launcherLogPath, sessionDirectory, workspaceRoot } from "./start-dashboard-paths.mjs";
+export const launcherDiagnostics = createDashboardDiagnostics(workspaceRoot, "launcher");
+process.env.ZAIP_DASHBOARD_LAUNCH_ID = launcherDiagnostics.correlationId;
 export function appendLauncherLog(message) {
+  launcherDiagnostics.log("launcher_message", { message });
   try {
     mkdirSync(sessionDirectory, { recursive: true });
     appendFileSync(
       launcherLogPath,
-      `[${new Date().toISOString()}] ${stripTerminalControlCodes(message)}\n`,
+      `[${new Date().toISOString()}] ${stripTerminalControlCodes(sanitizeDiagnostic(message))}\n`,
       "utf8",
     );
   } catch {

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

@@ -55,12 +55,18 @@ export async function startDashboardServer({
         ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "0",
         ZAIP_SQLITE_DB_PATH: dbPath,
       },
-      stdio: ["ignore", "ignore", "pipe"],
+      stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
     onChildStarted(child);
+    appendLog(`Runtime spawned: pid=${child.pid} port=${port} attempt=${attempt}`);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) =>
+      appendLog(`runtime stdout: ${String(chunk).slice(0, 16000)}`),
+    );
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
+      appendLog(`runtime stderr: ${String(chunk).slice(0, 16000)}`);
       stderr = `${stderr}${chunk}`.slice(-4_000);
       startupTelemetryBuffer = `${startupTelemetryBuffer}${String(chunk)}`;
       const lines = startupTelemetryBuffer.split("\n");

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

@@ -3,7 +3,6 @@ import {
   dashboardUrl,
   findAvailablePortWithFallback,
   openBrowser,
-  preferredPort,
 } from "./start-dashboard-navigation.mjs";
 
 export {
@@ -23,6 +22,7 @@ import {
 import {
   appendLauncherLog,
   formatLauncherError,
+  launcherDiagnostics,
   stripTerminalControlCodes,
 } from "./start-dashboard-logging.mjs";
 import {
@@ -36,7 +36,6 @@ import {
   lockHeartbeatFloorMs,
   lockPath,
   lockTimeoutMs,
-  maxPortAttempts,
   maxPortHistory,
   maxServerStartAttempts,
   nodeCompileCacheDirectory,
@@ -494,6 +493,7 @@ async function startDashboardServer(
   });
 }
 async function main() {
+  launcherDiagnostics.log("launcher_entered");
   let ownedChild = null;
   let currentSession = null;
   let launchPage = null;
@@ -741,9 +741,8 @@ async function waitForDashboard(port, child) {
     await delay(100);
   }
 }
-function delay(milliseconds) {
-  return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
-}
+const delay = (milliseconds) =>
+  new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
 const isMain = process.argv[1]
   ? resolve(process.argv[1]) === fileURLToPath(import.meta.url)
   : false;

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

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

package/templates/.agents/dashboard/packages/ui/src/DashboardHeader.test.mjs

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it } from "vitest";
+import { DashboardHeader } from "./DashboardHeader.tsx";
 
 const styles = readFileSync(new URL("ui.css", import.meta.url), "utf8");
-const headerSource = readFileSync(new URL("DashboardHeader.tsx", import.meta.url), "utf8");
 
 describe("DashboardHeader", () => {
   it("optically balances the repository badge horizontal spacing", () => {
@@ -10,12 +12,39 @@ describe("DashboardHeader", () => {
     expect(rule).toContain("padding-block: 0.3rem");
     expect(rule).toContain("padding-inline: 0.6rem 0.72rem");
   });
-  it("labels the timestamp as telemetry rather than overall snapshot freshness", () => {
-    expect(headerSource).toContain('updated: "Última telemetria"');
-    expect(headerSource).toContain('waiting: "Sem telemetria medida"');
+  it.each(["pt-BR", "en-US"])("shows only snapshot freshness in %s", (locale) => {
+    const telemetry = "2026-09-29T11:32:27Z";
+    const snapshot = "2026-09-29T12:59:35Z";
+    const markup = renderHeader({ locale, lastUpdatedAt: telemetry, snapshotUpdatedAt: snapshot });
+    const formatted = new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "medium" });
+    expect(markup.match(/<small>/g)).toHaveLength(1);
+    expect(markup).toContain(locale === "pt-BR" ? "Última Atualização" : "Last Updated");
+    expect(markup).toContain(formatted.format(new Date(snapshot)));
+    expect(markup).not.toContain(formatted.format(new Date(telemetry)));
+  });
+  it("keeps an unavailable snapshot explicit even when telemetry exists", () => {
+    const markup = renderHeader({ lastUpdatedAt: "2026-09-29T11:32:27Z" });
+    expect(markup.match(/<small>/g)).toHaveLength(1);
+    expect(markup).toContain("Atualização indisponível");
+    expect(markup).not.toContain("11:32:27");
   });
 });
 
+function renderHeader(props) {
+  return renderToStaticMarkup(
+    createElement(DashboardHeader, {
+      filters: null,
+      lastUpdatedAt: null,
+      loading: false,
+      locale: "pt-BR",
+      onLocaleChange() {},
+      onRefresh() {},
+      title: "Dashboard ZAIP AIOS",
+      ...props,
+    }),
+  );
+}
+
 function cssRule(source, selector) {
   const match = [...source.matchAll(/([^{}]+)\{([^}]*)\}/g)].find((candidate) =>
     candidate[1]?.split(",").some((item) => item.trim() === selector),

package/templates/.agents/dashboard/packages/ui/src/DashboardHeader.tsx

@@ -7,7 +7,7 @@ const zaipLogoUrl = new URL("../../../../config/src/logo_novo_azul.png", import.
 export function DashboardHeader({
   filters,
   filtersActive = false,
-  lastUpdatedAt,
+  snapshotUpdatedAt = null,
   loading,
   locale,
   onLocaleChange,
@@ -19,6 +19,7 @@ export function DashboardHeader({
   filters: ReactNode;
   filtersActive?: boolean;
   lastUpdatedAt: string | null;
+  snapshotUpdatedAt?: string | null;
   loading: boolean;
   locale: DashboardHeaderLocale;
   onLocaleChange: (locale: DashboardHeaderLocale) => void;
@@ -38,8 +39,8 @@ export function DashboardHeader({
           refresh: "Atualizar",
           refreshing: "Atualizando…",
           settings: "Configurações",
-          updated: "Última telemetria",
-          waiting: "Sem telemetria medida",
+          updated: "Última Atualização",
+          waiting: "Atualização indisponível",
         }
       : {
           filters: "Filters",
@@ -47,13 +48,13 @@ export function DashboardHeader({
           refresh: "Refresh",
           refreshing: "Refreshing…",
           settings: "Settings",
-          updated: "Last telemetry",
-          waiting: "No measured telemetry",
+          updated: "Last Updated",
+          waiting: "Update unavailable",
         };
   const updatedLabel =
-    lastUpdatedAt === null
+    snapshotUpdatedAt === null
       ? copy.waiting
-      : `${copy.updated} ${new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "medium" }).format(new Date(lastUpdatedAt))}`;
+      : `${copy.updated} ${new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "medium" }).format(new Date(snapshotUpdatedAt))}`;
   const changeLocale = (next: DashboardHeaderLocale) => {
     onLocaleChange(next);
     setLocaleOpen(false);