@zaip-ai/cli 4.9.0 → 5.1.0

package/templates/.agents/dashboard/apps/frontend/src/AppOverlays.tsx

@@ -35,12 +35,12 @@ export function AppOverlays({
   documentDetail,
   helpOpen,
   loadingArea,
-  operations,
   reconciliationResult,
   refreshDialog,
   showTrace,
   trace,
   traceLink,
+  traceMacroLoading,
   traceLoadingTaskId,
   closeDocument,
   onCloseHelp,
@@ -65,8 +65,14 @@ export function AppOverlays({
   trace: TaskTrace | null;
   traceLink:
     | { kind: "change"; row: ChangeProjection }
-    | { kind: "macro"; label: "PRD" | "SPEC"; row: MacroProjection }
+    | {
+        kind: "macro";
+        label: "PRD" | "SPEC";
+        row: MacroProjection;
+        projection: OperationsProjection;
+      }
     | null;
+  traceMacroLoading: { label: "PRD" | "SPEC"; id: string } | null;
   traceLoadingTaskId: string | null;
   closeDocument: () => void;
   onCloseHelp: () => void;
@@ -112,9 +118,9 @@ export function AppOverlays({
             onOpenTrace(taskId);
           }}
           row={traceLink.row}
-          runs={operations.runs}
-          specs={operations.specs}
-          tasks={operations.tasks}
+          runs={traceLink.projection.runs}
+          specs={traceLink.projection.specs}
+          tasks={traceLink.projection.tasks}
         />
       ) : null}
       {documentDetail ? (
@@ -190,8 +196,11 @@ export function AppOverlays({
           onDismiss={onDismissReconciliation}
         />
       ) : null}
-      {loadingArea !== null && refreshDialog === null ? (
-        <DashboardLoadingNotice area={loadingArea} locale={costLocale} />
+      {(loadingArea !== null || traceMacroLoading !== null) && refreshDialog === null ? (
+        <DashboardLoadingNotice
+          area={traceMacroLoading === null ? (loadingArea ?? "operations") : "operations"}
+          locale={costLocale}
+        />
       ) : null}
     </>
   );

package/templates/.agents/dashboard/apps/frontend/src/__tests__/app-composition-support.ts

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 export function readAppCompositionSource(): string {
   return [
     "use-dashboard-app-model.tsx",
+    "use-dashboard-locale.ts",
     "AppDashboardContent.tsx",
     "use-app-work-board.ts",
     "dashboard-cost-facts.ts",

package/templates/.agents/dashboard/apps/frontend/src/cost-period-refresh.test.ts

@@ -73,7 +73,7 @@ describe("Cost period refresh", () => {
     expect(activeCostReload).toContain(
       "[costs?.currency, currency, failedArea, loadCostSummary, operations]",
     );
-    expect(app).toContain("}, [api, currency, operationsPeriod]);");
+    expect(app).toContain("}, [api, currency, operationsPeriod, currencyRef]);");
     expect(app).toContain("costsLoadedRef.current = false;");
   });
 

package/templates/.agents/dashboard/apps/frontend/src/operations-period-render.test.ts

@@ -37,6 +37,7 @@ function renderPeriod(preset: "today" | "yesterday", loading = false) {
       onDateChange: vi.fn(),
       onLocaleChange: vi.fn(),
       onOpenDocument: vi.fn(),
+      onOpenMacro: vi.fn(),
       onOpenTask: vi.fn(async () => false),
       onPriorityChange: vi.fn(async () => undefined),
       onRefresh: vi.fn(),
@@ -92,6 +93,7 @@ describe("App-owned Operations period render", () => {
           onDateChange: vi.fn(),
           onLocaleChange: vi.fn(),
           onOpenDocument: vi.fn(),
+          onOpenMacro: vi.fn(),
           onOpenTask: vi.fn(async () => false),
           onPriorityChange: vi.fn(async () => undefined),
           onRefresh: vi.fn(),

package/templates/.agents/dashboard/apps/frontend/src/use-app-trace-documents.navigation.test.tsx

@@ -0,0 +1,125 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const browserRequire = createRequire(
+  fileURLToPath(new URL("../../../tests/e2e/package.json", import.meta.url)),
+);
+const { chromium, expect: browserExpect } = browserRequire("@playwright/test");
+
+describe("macro trace navigation from a compact overview", () => {
+  it("hydrates exact macro details, keeps linked rows, and ignores stale macro and Task requests", async () => {
+    const esbuild = browserRequire("esbuild");
+    const harness = await esbuild.build({
+      bundle: true,
+      format: "iife",
+      logLevel: "silent",
+      platform: "browser",
+      write: false,
+      stdin: {
+        contents: `
+          import React, { useState } from "react";
+          import { createRoot } from "react-dom/client";
+          import { useAppTraceDocuments } from "./use-app-trace-documents.js";
+
+          const pending = [];
+          window.__macroTraceProbe = { pending };
+          const api = {
+            operations: (_period, _scope, signal) => new Promise((resolve) => {
+              pending.push({ resolve, signal });
+            }),
+            taskTrace: async (id) => ({ task_id: id, task_title: id }),
+            prd: async (id) => ({ id, title: id, body: "Full document", artifact_path: "prds/one.md" }),
+          };
+          function Harness() {
+            const [error, setError] = useState(null);
+            const [, setFailedArea] = useState(null);
+            const [, setLoadingArea] = useState(null);
+            const state = useAppTraceDocuments({
+              api,
+              operations: { prds: [], specs: [], tasks: [], runs: [], changes: [] },
+              isOperationsDetailLoaded: () => false,
+              setError,
+              setFailedArea,
+              setLoadingArea,
+            });
+            return <>
+              <button onClick={() => void state.openTraceMacro("SPEC", "SPEC-TARGET")}>Open SPEC</button>
+              <button onClick={() => void state.openTraceMacro("PRD", "PRD-TARGET")}>Open PRD</button>
+              <button onClick={() => void state.openTrace("TASK-TARGET")}>Open Task</button>
+              <button onClick={() => void state.openDocument("prd", "PRD-TARGET")}>Read PRD</button>
+              <output id="state">{JSON.stringify({
+                macro: state.traceLink?.kind === "macro" ? state.traceLink.row.id : null,
+                kind: state.traceLink?.kind === "macro" ? state.traceLink.row.kind : null,
+                linkedTaskIds: state.traceLink?.kind === "macro"
+                  ? state.traceLink.projection.tasks.map((row) => row.id) : [],
+                loading: state.traceMacroLoading?.id ?? null,
+                task: state.trace?.task_id ?? null,
+                document: state.documentDetail?.preview.id ?? null,
+                error,
+              })}</output>
+            </>;
+          }
+          createRoot(document.getElementById("root")).render(<Harness />);
+        `,
+        loader: "tsx",
+        resolveDir: fileURLToPath(new URL(".", import.meta.url)),
+        sourcefile: "macro-trace-navigation-harness.tsx",
+      },
+    });
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const page = await browser.newPage();
+      const pageErrors: string[] = [];
+      page.on("pageerror", (error: Error) => pageErrors.push(error.message));
+      await page.setContent('<div id="root"></div>');
+      await page.addScriptTag({ content: harness.outputFiles[0].text });
+      const state = () => page.locator("#state");
+      const resolve = (index: number, prds: unknown[], specs: unknown[]) =>
+        page.evaluate(
+          ({ index, prds, specs }: { index: number; prds: unknown[]; specs: unknown[] }) => {
+            const request = (
+              window as typeof window & {
+                __macroTraceProbe: { pending: Array<{ resolve: (value: unknown) => void }> };
+              }
+            ).__macroTraceProbe.pending[index];
+            if (!request) throw new Error(`Missing pending macro request ${index}`);
+            request.resolve({
+              prds,
+              specs,
+              tasks: [{ id: "TASK-LINKED" }],
+              runs: [],
+            });
+          },
+          { index, prds, specs },
+        );
+
+      await page.getByRole("button", { name: "Open SPEC" }).click();
+      await browserExpect(state()).toContainText('"loading":"SPEC-TARGET"');
+      await page.getByRole("button", { name: "Open PRD" }).click();
+      await browserExpect(state()).toContainText('"loading":"PRD-TARGET"');
+      await resolve(0, [], [{ id: "SPEC-TARGET", kind: "spec" }]);
+      await browserExpect(state()).toContainText('"macro":null');
+      await resolve(1, [{ id: "PRD-TARGET", kind: "prd" }], []);
+      await browserExpect(state()).toContainText('"macro":"PRD-TARGET"');
+      await browserExpect(state()).toContainText('"linkedTaskIds":["TASK-LINKED"]');
+      await page.getByRole("button", { name: "Read PRD" }).click();
+      await browserExpect(state()).toContainText('"document":"PRD-TARGET"');
+
+      await page.getByRole("button", { name: "Open SPEC" }).click();
+      await page.getByRole("button", { name: "Open Task" }).click();
+      await browserExpect(state()).toContainText('"task":"TASK-TARGET"');
+      await resolve(2, [], [{ id: "SPEC-TARGET", kind: "spec" }]);
+      await browserExpect(state()).toContainText('"macro":null');
+
+      await page.getByRole("button", { name: "Open PRD" }).click();
+      await resolve(3, [{ id: "PRD-OTHER", kind: "prd" }], []);
+      await browserExpect(state()).toContainText('"error":"PRD PRD-TARGET not found"');
+      await browserExpect(state()).toContainText('"loading":null');
+      expect(pageErrors).toEqual([]);
+      await page.close();
+    } finally {
+      await browser.close();
+    }
+  }, 60_000);
+});

package/templates/.agents/dashboard/apps/frontend/src/use-app-trace-documents.ts

@@ -13,12 +13,14 @@ import type { DashboardApiClient } from "./dashboard-api.js";
 export function useAppTraceDocuments({
   api,
   operations,
+  isOperationsDetailLoaded,
   setError,
   setFailedArea,
   setLoadingArea,
 }: {
   api: DashboardApiClient;
   operations: OperationsProjection | null;
+  isOperationsDetailLoaded: () => boolean;
   setError: Dispatch<SetStateAction<string | null>>;
   setFailedArea: Dispatch<SetStateAction<LoadingArea | null>>;
   setLoadingArea: Dispatch<SetStateAction<LoadingArea | null>>;
@@ -34,16 +36,31 @@ export function useAppTraceDocuments({
   } | null>(null);
   const [traceLink, setTraceLink] = useState<
     | { kind: "change"; row: ChangeProjection }
-    | { kind: "macro"; label: "PRD" | "SPEC"; row: MacroProjection }
+    | {
+        kind: "macro";
+        label: "PRD" | "SPEC";
+        row: MacroProjection;
+        projection: OperationsProjection;
+      }
     | null
   >(null);
   const documentRequestId = useRef(0);
   const traceRequestId = useRef(0);
+  const macroRequestId = useRef(0);
+  const macroAbortController = useRef<AbortController | null>(null);
+  const [traceMacroLoading, setTraceMacroLoading] = useState<{
+    label: "PRD" | "SPEC";
+    id: string;
+  } | null>(null);
   const traceAbortController = useRef<AbortController | null>(null);
   const [traceLoadingTaskId, setTraceLoadingTaskId] = useState<string | null>(null);
   const [selectedTraceTaskId, setSelectedTraceTaskId] = useState("");
 
   async function openTrace(taskId: string) {
+    macroRequestId.current += 1;
+    macroAbortController.current?.abort();
+    setTraceMacroLoading(null);
+    setTraceLink(null);
     const requestId = ++traceRequestId.current;
     traceAbortController.current?.abort();
     const controller = new AbortController();
@@ -92,18 +109,58 @@ export function useAppTraceDocuments({
     setTraceLink({ kind: "change", row });
   }
 
-  function openTraceMacro(label: "PRD" | "SPEC", id: string) {
-    const rows = label === "PRD" ? operations?.prds : operations?.specs;
-    const row = rows?.find((macro) => macro.id === id);
-    if (row === undefined) return;
+  async function openTraceMacro(label: "PRD" | "SPEC", id: string) {
+    const requestId = ++macroRequestId.current;
+    macroAbortController.current?.abort();
+    macroAbortController.current = null;
+    traceRequestId.current += 1;
+    traceAbortController.current?.abort();
+    traceAbortController.current = null;
+    setTraceLoadingTaskId(null);
+    setLoadingArea((current) => (current === "traceability" ? null : current));
+    setError(null);
+    setFailedArea(null);
     setTrace(null);
-    setTraceLink({ kind: "macro", label, row });
+    setTraceLink(null);
+    const rows = label === "PRD" ? operations?.prds : operations?.specs;
+    const existing = rows?.find((macro) => macro.id === id && macro.kind === label.toLowerCase());
+    if (existing && operations && isOperationsDetailLoaded()) {
+      setTraceMacroLoading(null);
+      setTraceLink({ kind: "macro", label, row: existing, projection: operations });
+      return;
+    }
+    const controller = new AbortController();
+    macroAbortController.current = controller;
+    setTraceMacroLoading({ label, id });
+    try {
+      // The compact first fold has ranking IDs but omits macro and linked Task rows.
+      // Hydrate only after the user requests this traceability dialog.
+      const projection = await api.operations(undefined, "detail", controller.signal);
+      if (requestId !== macroRequestId.current || controller.signal.aborted) return;
+      const row = (label === "PRD" ? projection.prds : projection.specs).find(
+        (macro) => macro.id === id && macro.kind === label.toLowerCase(),
+      );
+      if (!row) throw new Error(`${label} ${id} not found`);
+      setTraceLink({ kind: "macro", label, row, projection });
+    } catch (cause) {
+      if (requestId !== macroRequestId.current || controller.signal.aborted) return;
+      setError(cause instanceof Error ? cause.message : String(cause));
+    } finally {
+      if (requestId === macroRequestId.current) {
+        if (macroAbortController.current === controller) macroAbortController.current = null;
+        setTraceMacroLoading(null);
+      }
+    }
   }
 
   async function openDocument(kind: "prd" | "spec", id: string) {
-    const preview = (kind === "prd" ? operations?.prds : operations?.specs)?.find(
-      (macro) => macro.id === id,
-    );
+    const preview =
+      (kind === "prd" ? operations?.prds : operations?.specs)?.find((macro) => macro.id === id) ??
+      (traceLink?.kind === "macro"
+        ? (kind === "prd" ? traceLink.projection.prds : traceLink.projection.specs).find(
+            (macro) => macro.id === id,
+          )
+        : undefined);
     if (!preview) return;
     const requestId = ++documentRequestId.current;
     const label = kind === "prd" ? "PRD" : "SPEC";
@@ -143,6 +200,7 @@ export function useAppTraceDocuments({
     setTraceTasks,
     trace,
     traceLink,
+    traceMacroLoading,
     traceLoadingTaskId,
     traceTasks,
   };

package/templates/.agents/dashboard/apps/frontend/src/use-dashboard-app-model.tsx

@@ -62,6 +62,7 @@ import { useAppTraceDocuments } from "./use-app-trace-documents.js";
 import { useAppTraceTaskPagination } from "./use-app-trace-task-pagination.js";
 import { useAppWorkBoard } from "./use-app-work-board.js";
 import { useAppWorkListPage } from "./use-app-work-list-page.js";
+import { useDashboardLocale } from "./use-dashboard-locale.js";
 import { useOperationsDetailExport } from "./use-operations-detail-export.js";
 import { useSnapshotNotice } from "./use-snapshot-notice.js";
 import "./loading-feedback.css";
@@ -103,18 +104,8 @@ export function useDashboardAppModel() {
     useState<OverviewClassificationPages>({});
   const [costs, setCosts] = useState<CostMonitorProjection | null>(null);
   const [displayedCosts, setDisplayedCosts] = useState<CostMonitorProjection | null>(null);
-  const [costLocale, setCostLocale] = useState<CostLocale>(savedLocale);
-  const [currency, setCurrency] = useState<CostCurrency>(() =>
-    window.localStorage.getItem(currencyKey) === "USD" ? "USD" : "BRL",
-  );
-  const currencyRef = useRef(currency);
-  currencyRef.current = currency;
-  // Language is the global selector's source of truth for the paired display
-  // currency, so Operations and Cost Monitor cannot diverge.
-  const changeDashboardLocale = useCallback((next: CostLocale) => {
-    setCostLocale(next);
-    setCurrency(next === "en-US" ? "USD" : "BRL");
-  }, []);
+  const { costLocale, currency, setCurrency, currencyRef, changeDashboardLocale } =
+    useDashboardLocale();
   const [operationsPeriod, setOperationsPeriod] = useState(() => defaultOperationsPeriod);
   // All Time may update its displayed factual range without changing the
   // unbounded request identity. Keep the refresh callback stable for that
@@ -174,6 +165,7 @@ export function useDashboardAppModel() {
       cancelled = true;
     };
   }, [api, applyDashboardIdentity]);
+  const operationsDetailLoadedRef = useRef(false);
   const {
     closeDocument,
     documentDetail,
@@ -181,6 +173,7 @@ export function useDashboardAppModel() {
     openTrace,
     openTraceChange,
     openTraceMacro,
+    traceMacroLoading,
     selectedTraceTaskId,
     setSelectedTraceTaskId,
     setTrace,
@@ -191,7 +184,14 @@ export function useDashboardAppModel() {
     traceLink,
     traceLoadingTaskId,
     traceTasks,
-  } = useAppTraceDocuments({ api, operations, setError, setFailedArea, setLoadingArea });
+  } = useAppTraceDocuments({
+    api,
+    operations,
+    isOperationsDetailLoaded: () => operationsDetailLoadedRef.current,
+    setError,
+    setFailedArea,
+    setLoadingArea,
+  });
   const { loadMoreTraceTasks, traceTasksHasMore, traceTasksLoading } = useAppTraceTaskPagination(
     api,
     traceTasks,
@@ -205,7 +205,6 @@ export function useDashboardAppModel() {
   const costSummaryRequestVersion = useRef(0);
   const costSummaryAbortRef = useRef<AbortController | null>(null);
   const costsLoadedRef = useRef(false);
-  const operationsDetailLoadedRef = useRef(false);
   const operationsDetailCancelRef = useRef<(() => void) | null>(null);
   const operationsDetailAbortRef = useRef<AbortController | null>(null);
   const operationsPageAbortRef = useRef<AbortController | null>(null);
@@ -571,7 +570,7 @@ export function useDashboardAppModel() {
         setLoadingArea((current) => (current === "costs" ? null : current));
       if (costSummaryAbortRef.current === controller) costSummaryAbortRef.current = null;
     }
-  }, [api, currency, operationsPeriod]);
+  }, [api, currency, operationsPeriod, currencyRef]);
 
   // The global language selector can request USD while Operations is active.
   // Acquire its coherent Cost Monitor snapshot here instead of requiring a
@@ -695,6 +694,7 @@ export function useDashboardAppModel() {
     openTraceChange,
     openTraceMacro,
     selectedTraceTaskId,
+    traceMacroLoading,
     trace,
     traceLoadingTaskId,
     traceTasksHasMore,

package/templates/.agents/dashboard/apps/frontend/src/use-dashboard-locale.ts

@@ -0,0 +1,18 @@
+import type { CostCurrency, CostLocale } from "@zaip-ai/dashboard-cost-monitor/react";
+import { useCallback, useRef, useState } from "react";
+import { currencyKey, savedLocale } from "./app-preferences.js";
+export function useDashboardLocale() {
+  const [costLocale, setCostLocale] = useState<CostLocale>(savedLocale);
+  const [currency, setCurrency] = useState<CostCurrency>(() =>
+    window.localStorage.getItem(currencyKey) === "USD" ? "USD" : "BRL",
+  );
+  const currencyRef = useRef(currency);
+  currencyRef.current = currency;
+  // Language is the global selector's source of truth for the paired display
+  // currency, so Operations and Cost Monitor cannot diverge.
+  const changeDashboardLocale = useCallback((next: CostLocale) => {
+    setCostLocale(next);
+    setCurrency(next === "en-US" ? "USD" : "BRL");
+  }, []);
+  return { costLocale, currency, setCurrency, currencyRef, changeDashboardLocale };
+}

package/templates/.agents/dashboard/modules/cost-monitor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-cost-monitor",
-  "version": "4.9.0",
+  "version": "5.1.0",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/modules/cost-monitor/src/contracts.ts

@@ -69,7 +69,7 @@ export interface CostRunRow {
   run_id: string;
   /** Lifecycle Execution that owns this Run, retained for the Executions tab period filter. */
   execution_id: string | null;
-  conversation_id: string;
+  conversation_id: string | null;
   task_id: string | null;
   task_title: string;
   task_status: string;
@@ -81,7 +81,14 @@ export interface CostRunRow {
   parent_run_id: string | null;
   run_role: "intake" | "orchestrator" | "subagent";
   run_kind: "run" | "subrun";
-  run_purpose: "intake" | "orchestration" | "execution" | "review" | "audit" | "finalization";
+  run_purpose:
+    | "observation"
+    | "intake"
+    | "orchestration"
+    | "execution"
+    | "review"
+    | "audit"
+    | "finalization";
   requires_finalizer: boolean;
   client: string;
   agent: string;
@@ -95,7 +102,7 @@ export interface CostRunRow {
   call_count: number | null;
   status: string;
   phase: string;
-  origin: "conversation" | "task" | "spec" | "prd";
+  origin: "observation" | "conversation" | "task" | "spec" | "prd";
   work_type: "new" | "rework";
   started_at: string;
   finished_at: string | null;

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostFilters.run-page.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { loadCostMonitorRunPage } from "./CostFilters.js";
+import { emptyCostFilters, loadCostMonitorRunPage } from "./CostFilters.js";
 
 describe("Cost Monitor invocation page loading", () => {
   it("uses a ten-row default for the remote invocation page", async () => {
@@ -7,6 +7,7 @@ describe("Cost Monitor invocation page loading", () => {
     await loadCostMonitorRunPage({
       currency: "BRL",
       offset: 0,
+      filters: { ...emptyCostFilters, query: "target title" },
       fetcher: async (url) => {
         calls.push(String(url));
         return new Response(JSON.stringify({ runs: [] }), { status: 200 });
@@ -14,5 +15,8 @@ describe("Cost Monitor invocation page loading", () => {
     });
 
     expect(new URL(calls[0]!, "http://dashboard.local").searchParams.get("limit")).toBe("10");
+    expect(new URL(calls[0]!, "http://dashboard.local").searchParams.get("query")).toBe(
+      "target title",
+    );
   });
 });

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostGroupsTable.period-values.test.tsx

@@ -22,7 +22,7 @@ const unavailableGroup = {
 } as const;
 
 describe("period group values", () => {
-  it("discloses presentation zero without changing null sorting", () => {
+  it("preserves unavailable tokens alongside disclosed presentation zeros and null sorting", () => {
     const table = CostGroupsTable({
       rows: [unavailableGroup],
       currency: "BRL",
@@ -53,7 +53,7 @@ describe("period group values", () => {
     );
     expect([duration.props.children, tokens.props.children, cost.props.children]).toEqual([
       "0",
-      "0",
+      "—",
       formatAuditableCurrency(0, "BRL", "pt-BR"),
     ]);
     expect(

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostTables-keeps-legacy-codex-identity-fields-blank.test.ts

@@ -179,7 +179,7 @@ describe("grouped cost availability", () => {
     ).toBe("0");
     expect(
       columns.find((column) => column.key === "cost")?.render?.({ ...model, estimated_brl: null }),
-    ).toBe("0");
+    ).toBe("—");
     expect(
       columns
         .find((column) => column.key === "tokens")
@@ -324,14 +324,14 @@ describe("grouped cost availability", () => {
       expect(column(key)?.description).toContain("projeção SQLite/API");
       expect(column(key)?.hidden).not.toBe(true);
     }
-    expect(column("duration")?.render?.(unavailableRun)).toBe("0");
-    expect(column("inputTokens")?.render?.(unavailableRun)).toBe("0");
+    expect(column("duration")?.render?.(unavailableRun)).toBe("—");
+    expect(column("inputTokens")?.render?.(unavailableRun)).toBe("—");
     expect(column("inputRate")?.render?.(unavailableRun)).toBe("0,00");
     expect(column("contextMultiplier")?.render?.(unavailableRun)).toBe("0");
     expect(column("inputCost")?.render?.(unavailableRun)).toContain("0,00");
     expect(column("fxRate")?.render?.(unavailableRun)).toBe("R$ 0,00");
-    expect(column("recordedBrl")?.render?.(unavailableRun)).toBe("0");
-    expect(column("cost")?.render?.(unavailableRun)).toBe("0");
+    expect(column("recordedBrl")?.render?.(unavailableRun)).toBe("—");
+    expect(column("cost")?.render?.(unavailableRun)).toBe("—");
   });
   it("provides a clear scroll label for the detailed Runs table", () => {
     expect(costRunsScrollLabel("pt-BR")).toBe(