@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -32,8 +32,6 @@ type DocumentDetail = {
 export function AppOverlays({
   costLocale,
   documentDetail,
-  error,
-  failedArea,
   helpOpen,
   loadingArea,
   operations,
@@ -46,7 +44,6 @@ export function AppOverlays({
   closeDocument,
   onCloseHelp,
   onCloseTrace,
-  onDismissError,
   onDismissReconciliation,
   onOpenDocument,
   onOpenTrace,
@@ -54,13 +51,10 @@ export function AppOverlays({
   onOpenTraceMacro,
   onRefreshCancel,
   onRefreshFromDialog,
-  onRetry,
   setTraceLink,
 }: {
   costLocale: CostLocale;
   documentDetail: DocumentDetail | null;
-  error: string | null;
-  failedArea: LoadingArea | null;
   helpOpen: boolean;
   loadingArea: LoadingArea | null;
   operations: OperationsProjection;
@@ -76,7 +70,6 @@ export function AppOverlays({
   closeDocument: () => void;
   onCloseHelp: () => void;
   onCloseTrace: () => void;
-  onDismissError: () => void;
   onDismissReconciliation: () => void;
   onOpenDocument: (kind: "prd" | "spec", id: string) => void;
   onOpenTrace: (taskId: string) => void;
@@ -84,24 +77,10 @@ export function AppOverlays({
   onOpenTraceMacro: (label: "PRD" | "SPEC", id: string) => void;
   onRefreshCancel: () => void;
   onRefreshFromDialog: (reconcileOpenWork: boolean) => void;
-  onRetry: () => void;
   setTraceLink: (value: null) => void;
 }) {
   return (
     <>
-      {error ? (
-        <div aria-live="assertive" className="app-warning" role="alert">
-          <span>{error}</span>
-          {failedArea ? (
-            <button onClick={onRetry} type="button">
-              {costLocale === "pt-BR" ? "Tentar novamente" : "Try again"}
-            </button>
-          ) : null}
-          <button onClick={onDismissError} type="button">
-            ×
-          </button>
-        </div>
-      ) : null}
       {showTrace ? null : traceLoadingTaskId ? (
         <TaskTraceLoadingPanel locale={costLocale} taskId={traceLoadingTaskId} />
       ) : trace ? (

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

@@ -35,6 +35,7 @@ type DashboardAlternateContentProps = {
   onLoadingChange: (loading: boolean) => void;
   onLocaleChange: (locale: CostLocale) => void;
   onOpenTrace: (taskId: string) => void;
+  onLoadMoreTraceTasks: (loadAll?: boolean) => Promise<unknown>;
   onRefresh: () => void;
   onRetry: () => void;
   onSelectTraceTask: (taskId: string) => void;
@@ -44,6 +45,8 @@ type DashboardAlternateContentProps = {
   selectedTraceTaskId: string;
   trace: TaskTrace | null;
   traceLoadingTaskId: string | null;
+  traceTasksHasMore: boolean;
+  traceTasksLoading: boolean;
   traceTasks: OperationsProjection["tasks"];
 };
 
@@ -64,6 +67,7 @@ export function renderDashboardAlternateContent({
   onLoadingChange,
   onLocaleChange,
   onOpenTrace,
+  onLoadMoreTraceTasks,
   onRefresh,
   onRetry,
   onSelectTraceTask,
@@ -73,6 +77,8 @@ export function renderDashboardAlternateContent({
   selectedTraceTaskId,
   trace,
   traceLoadingTaskId,
+  traceTasksHasMore,
+  traceTasksLoading,
   traceTasks,
 }: DashboardAlternateContentProps) {
   if (dashboardView === "cost-monitor") {
@@ -112,17 +118,20 @@ export function renderDashboardAlternateContent({
   if (dashboardView === "traceability") {
     return () => (
       <Suspense fallback={<LoadingPanel area="operations" locale={costLocale} />}>
-      <TraceabilityWorkspace
-        loadingTaskId={traceLoadingTaskId}
-        locale={costLocale}
-        onOpenChange={onOpenTraceChange}
-        onOpenPrd={(prdId) => onOpenTraceMacro("PRD", prdId)}
-        onOpenSpec={(specId) => onOpenTraceMacro("SPEC", specId)}
-        onSelectTask={onSelectTraceTask}
-        selectedTaskId={selectedTraceTaskId}
-        tasks={traceTasks.length > 0 ? traceTasks : operations.tasks}
-        trace={trace}
-      />
+        <TraceabilityWorkspace
+          loadingTaskId={traceLoadingTaskId}
+          locale={costLocale}
+          onOpenChange={onOpenTraceChange}
+          onOpenPrd={(prdId) => onOpenTraceMacro("PRD", prdId)}
+          onOpenSpec={(specId) => onOpenTraceMacro("SPEC", specId)}
+          onLoadMoreTasks={onLoadMoreTraceTasks}
+          onSelectTask={onSelectTraceTask}
+          selectedTaskId={selectedTraceTaskId}
+          tasks={traceTasks.length > 0 ? traceTasks : operations.tasks}
+          hasMoreTasks={traceTasksHasMore}
+          isLoadingTasks={traceTasksLoading}
+          trace={trace}
+        />
       </Suspense>
     );
   }

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

@@ -4,16 +4,16 @@ import type {
   ProjectConfigSettings,
   ProjectOverview,
 } from "./dashboard-api.js";
+import { StackComponentEditor, StackVersions } from "./ProjectStackEditor.js";
 import {
   buildProjectSettingsPayload,
   defaultAutonomousExecution,
   lineList,
   projectSettingsDraft,
-  shortFrameworkVersion,
   type StackComponentsDraft,
+  shortFrameworkVersion,
   withDetectedStackVersions,
 } from "./project-settings-model.js";
-import { StackComponentEditor, StackVersions } from "./ProjectStackEditor.js";
 import "./project-settings-page.css";
 
 type Locale = "pt-BR" | "en-US";
@@ -22,7 +22,7 @@ const copy = {
     eyebrow: "Configurações",
     title: "Configuração do projeto",
     intro: "Edite o arquivo central do projeto com validação do schema antes da gravação.",
-    loading: "Carregando configurações do projeto…",
+    loading: "Carregando…",
     back: "Voltar ao dashboard",
     save: "Salvar configurações",
     saving: "Validando e salvando…",
@@ -190,10 +190,15 @@ export function ProjectSettingsPage({
   }
 
   if (config === null) {
+    const isLoading = error === null;
     return (
-      <main className="project-settings-state">
-        <div className="project-settings-state-card">
-          <span aria-hidden="true" className="project-settings-loader" />
+      <main aria-busy={isLoading} className="project-settings-state">
+        <div
+          aria-live={isLoading ? "polite" : "assertive"}
+          className="project-settings-state-card"
+          role={isLoading ? "status" : "alert"}
+        >
+          {isLoading ? <span aria-hidden="true" className="project-settings-loader" /> : null}
           <p>{text.eyebrow}</p>
           <h1>{error ?? text.loading}</h1>
           <button onClick={onClose} type="button">
@@ -229,7 +234,9 @@ export function ProjectSettingsPage({
           <div>
             <h2>
               {text.framework}
-              {shortFrameworkVersion(overview?.framework_version) ? ` - ${shortFrameworkVersion(overview?.framework_version)}` : ""}
+              {shortFrameworkVersion(overview?.framework_version)
+                ? ` - ${shortFrameworkVersion(overview?.framework_version)}`
+                : ""}
             </h2>
             <p>{text.frameworkHint}</p>
           </div>

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

@@ -131,8 +131,10 @@ export function StackVersions({
       <div>
         {components.map((component) => (
           <article key={component.name}>
-            <strong>{component.name}</strong>
-            <code>{component.version ?? text.versionUnavailable}</code>
+            <div className="project-stack-version-identity">
+              <strong>{component.name}</strong>
+              <code>{component.version ?? text.versionUnavailable}</code>
+            </div>
             <span className={`is-${component.verification}`}>
               {component.verification === "exact"
                 ? text.exact

package/templates/.agents/dashboard/apps/frontend/src/TraceabilityWorkspace.dom.e2e.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "@playwright/test";
+
+test("opens every task from a preselected traceability combobox and preserves search and keyboard selection", async ({
+  page,
+}) => {
+  const operations = page.waitForResponse(
+    (response) =>
+      response.status() === 200 &&
+      response.url().includes("/api/v2/operations") &&
+      response.url().includes("scope=quick"),
+  );
+  await page.goto("/?token=e2e-token");
+  await operations;
+
+  const traceabilityButton = page
+    .getByRole("navigation", { name: "Áreas do dashboard" })
+    .getByRole("button", { name: /Rastreabilidade/ });
+  await traceabilityButton.click();
+  await expect(traceabilityButton).toHaveAttribute("aria-current", "page");
+
+  const taskSelector = page.getByRole("combobox", { name: "Buscar task por nome ou ID" });
+  const taskOptions = page
+    .getByRole("listbox", { name: "Buscar task por nome ou ID" })
+    .getByRole("option");
+  const taskList = page.getByRole("listbox", { name: "Buscar task por nome ou ID" });
+  await expect(taskSelector).toBeVisible();
+  await expect(taskSelector).toHaveAttribute("aria-expanded", "false");
+
+  const selectedTitle = await taskSelector.inputValue();
+  await taskSelector.focus();
+  await expect(taskSelector).toHaveAttribute("aria-expanded", "true");
+  const initialTaskCount = await taskOptions.count();
+  expect(initialTaskCount).toBe(12);
+  await taskList.evaluate((element) => {
+    element.scrollTop = element.scrollHeight;
+    element.dispatchEvent(new Event("scroll", { bubbles: true }));
+  });
+  await expect.poll(() => taskOptions.count()).toBeGreaterThan(initialTaskCount);
+
+  await taskSelector.fill(selectedTitle);
+  await expect(taskOptions).toHaveCount(1);
+
+  await taskSelector.click();
+  await expect(taskOptions).toHaveCount(initialTaskCount);
+  const thirdOptionId = await taskOptions.nth(2).getAttribute("id");
+  await taskSelector.press("ArrowDown");
+  await taskSelector.press("ArrowDown");
+  const activeOptionId = await taskSelector.getAttribute("aria-activedescendant");
+  expect(activeOptionId).toBe(thirdOptionId);
+  const activeOption = page.locator(`[id="${activeOptionId}"]`);
+  const activeTitle = await activeOption.locator("strong").innerText();
+
+  await taskSelector.press("Enter");
+  await expect(taskSelector).toHaveAttribute("aria-expanded", "false");
+  await expect(taskSelector).toHaveValue(activeTitle);
+});

package/templates/.agents/dashboard/apps/frontend/src/TraceabilityWorkspace.test.ts

@@ -1,6 +1,10 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import { filterTraceabilityTasks, traceabilityTaskOptionId } from "./TraceabilityWorkspace.js";
+import {
+  filterTraceabilityTasks,
+  traceabilityTaskOptionId,
+  visibleTraceabilityTasks,
+} from "./TraceabilityWorkspace.js";
 
 describe("TraceabilityWorkspace task search", () => {
   const tasks = [
@@ -9,11 +13,22 @@ describe("TraceabilityWorkspace task search", () => {
   ] as never[];
 
   it("filters tasks by either title or ID", () => {
-    expect(filterTraceabilityTasks(tasks, "lançamento").map((task) => task.id)).toEqual(["TASK-ALPHA"]);
+    expect(filterTraceabilityTasks(tasks, "lançamento").map((task) => task.id)).toEqual([
+      "TASK-ALPHA",
+    ]);
     expect(filterTraceabilityTasks(tasks, "beta").map((task) => task.id)).toEqual(["TASK-BETA"]);
     expect(filterTraceabilityTasks(tasks, "missing")).toEqual([]);
   });
 
+  it("shows every task when the selected combobox is opened", () => {
+    expect(
+      visibleTraceabilityTasks(tasks, "Preparar lançamento", true).map((task) => task.id),
+    ).toEqual(["TASK-ALPHA", "TASK-BETA"]);
+    expect(
+      visibleTraceabilityTasks(tasks, "Preparar lançamento", false).map((task) => task.id),
+    ).toEqual(["TASK-ALPHA"]);
+  });
+
   it("keeps selection and keyboard interaction accessible", () => {
     const source = readFileSync(new URL("TraceabilityWorkspace.tsx", import.meta.url), "utf8");
 
@@ -24,6 +39,10 @@ describe("TraceabilityWorkspace task search", () => {
     expect(source).toContain('event.key === "Enter"');
     expect(source).toContain('event.key === "ArrowDown"');
     expect(source).toContain("setActiveIndex");
+    expect(source).toContain("onClick={() => openAllTasks()}");
+    expect(source).toContain("onFocus={() => openAllTasks()}");
+    expect(source).toContain("openAllTasks(false)");
+    expect(source).toContain("setShowAllTasks(true)");
     expect(source).toContain("aria-activedescendant");
     expect(source).toContain("traceabilityTaskOptionId(activeTaskId)");
     expect(source).toContain('role="status"');

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

@@ -1,10 +1,12 @@
-import { useEffect, useMemo, useState } from "react";
 import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
 import type { TaskTrace } from "@zaip-ai/dashboard-traceability/contracts";
 import { TaskTracePanel } from "@zaip-ai/dashboard-traceability/react";
+import { useEffect, useMemo, useState } from "react";
+import { nextTraceabilityVisibleCount } from "./traceability-task-pagination.js";
 import "./traceability-workspace.css";
 
 type TraceabilityTask = OperationsProjection["tasks"][number];
+export const traceabilityTaskInitialBatchSize = 12;
 
 export function filterTraceabilityTasks(
   tasks: readonly TraceabilityTask[],
@@ -17,6 +19,14 @@ export function filterTraceabilityTasks(
   );
 }
 
+export function visibleTraceabilityTasks(
+  tasks: readonly TraceabilityTask[],
+  query: string,
+  showAllTasks: boolean,
+): TraceabilityTask[] {
+  return showAllTasks ? [...tasks] : filterTraceabilityTasks(tasks, query);
+}
+
 export function traceabilityTaskOptionId(taskId: string): string {
   return `traceability-task-option-${taskId}`;
 }
@@ -24,6 +34,9 @@ export function traceabilityTaskOptionId(taskId: string): string {
 export function TraceabilityWorkspace({
   locale,
   loadingTaskId,
+  hasMoreTasks,
+  isLoadingTasks,
+  onLoadMoreTasks,
   onSelectTask,
   onOpenChange,
   onOpenPrd,
@@ -34,6 +47,9 @@ export function TraceabilityWorkspace({
 }: {
   locale: "pt-BR" | "en-US";
   loadingTaskId: string | null;
+  hasMoreTasks: boolean;
+  isLoadingTasks: boolean;
+  onLoadMoreTasks: (loadAll?: boolean) => Promise<unknown>;
   onSelectTask: (taskId: string) => void;
   onOpenChange: (changeId: string) => void;
   onOpenPrd: (prdId: string) => void;
@@ -48,11 +64,15 @@ export function TraceabilityWorkspace({
   const selectedTask = sortedTasks.find((task) => task.id === selectedTaskId);
   const [query, setQuery] = useState(() => selectedTask?.title ?? selectedTaskId);
   const [isListOpen, setIsListOpen] = useState(false);
+  const [showAllTasks, setShowAllTasks] = useState(false);
   const [activeIndex, setActiveIndex] = useState(0);
+  const [visibleCount, setVisibleCount] = useState(traceabilityTaskInitialBatchSize);
   const filteredTasks = useMemo(
-    () => filterTraceabilityTasks(sortedTasks, query),
-    [query, sortedTasks],
+    () => visibleTraceabilityTasks(sortedTasks, query, showAllTasks),
+    [query, showAllTasks, sortedTasks],
   );
+  const visibleTasks = filteredTasks.slice(0, visibleCount);
+  const hasMoreVisibleTasks = visibleTasks.length < filteredTasks.length;
   const searchInputId = "traceability-task-search";
   const resultsId = "traceability-task-results";
   const taskLabel = locale === "pt-BR" ? "Task selecionada" : "Selected task";
@@ -62,26 +82,48 @@ export function TraceabilityWorkspace({
 
   useEffect(() => {
     setQuery(selectedTask?.title ?? selectedTaskId);
-  }, [selectedTask?.title, selectedTaskId]);
-
-  useEffect(() => {
     setActiveIndex(0);
-  }, [query]);
+  }, [selectedTask?.title, selectedTaskId]);
 
   const selectTask = (task: TraceabilityTask) => {
     setQuery(task.title);
     setIsListOpen(false);
+    setShowAllTasks(false);
     onSelectTask(task.id);
   };
 
+  const openAllTasks = (resetList = true) => {
+    setIsListOpen(true);
+    setShowAllTasks(true);
+    if (resetList) {
+      setActiveIndex(0);
+      setVisibleCount(traceabilityTaskInitialBatchSize);
+    }
+  };
+
+  const loadMoreTasks = (event: React.UIEvent<HTMLDivElement>) => {
+    const { clientHeight, scrollHeight, scrollTop } = event.currentTarget;
+    if (scrollTop + clientHeight < scrollHeight - 32) return;
+    if (hasMoreTasks) void onLoadMoreTasks();
+    if (visibleTasks.length < filteredTasks.length) {
+      setVisibleCount((current) =>
+        nextTraceabilityVisibleCount(
+          current,
+          filteredTasks.length,
+          traceabilityTaskInitialBatchSize,
+        ),
+      );
+    }
+  };
+
   const onSearchKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
     if (event.key === "ArrowDown") {
       event.preventDefault();
-      setIsListOpen(true);
-      setActiveIndex((index) => Math.min(index + 1, Math.max(0, filteredTasks.length - 1)));
+      openAllTasks(false);
+      setActiveIndex((index) => Math.min(index + 1, Math.max(0, sortedTasks.length - 1)));
     } else if (event.key === "ArrowUp") {
       event.preventDefault();
-      setIsListOpen(true);
+      openAllTasks(false);
       setActiveIndex((index) => Math.max(0, index - 1));
     } else if (event.key === "Enter" && isListOpen) {
       const task = filteredTasks[activeIndex];
@@ -109,19 +151,33 @@ export function TraceabilityWorkspace({
             id={searchInputId}
             onChange={(event) => {
               setQuery(event.target.value);
+              setActiveIndex(0);
+              setShowAllTasks(false);
+              setVisibleCount(traceabilityTaskInitialBatchSize);
               setIsListOpen(true);
+              // Do not turn a keystroke into a full repository walk. More
+              // candidates are acquired only by explicit list scrolling; a
+              // server-side search can be wired here when its bounded query
+              // contract is available.
             }}
-            onFocus={() => setIsListOpen(true)}
+            onClick={() => openAllTasks()}
+            onFocus={() => openAllTasks()}
             onKeyDown={onSearchKeyDown}
             role="combobox"
             type="search"
             value={query}
           />
           {isListOpen ? (
-            <ul aria-label={searchLabel} className="traceability-task-results" id={resultsId} role="listbox">
+            <div
+              aria-label={searchLabel}
+              className="traceability-task-results"
+              id={resultsId}
+              onScroll={loadMoreTasks}
+              role="listbox"
+            >
               {filteredTasks.length > 0 ? (
-                filteredTasks.map((task, index) => (
-                  <li key={task.id} role="presentation">
+                visibleTasks.map((task, index) => (
+                  <div key={task.id} role="presentation">
                     <button
                       aria-selected={task.id === selectedTaskId}
                       className={index === activeIndex ? "is-active" : undefined}
@@ -131,16 +187,30 @@ export function TraceabilityWorkspace({
                       type="button"
                     >
                       <strong>{task.title}</strong>
-                      <small>{task.id}</small>
                     </button>
-                  </li>
+                  </div>
                 ))
               ) : (
-                <li className="traceability-task-no-results" role="status">
+                <div className="traceability-task-no-results" role="status">
                   {locale === "pt-BR" ? "Nenhuma task encontrada." : "No tasks found."}
-                </li>
+                </div>
               )}
-            </ul>
+            </div>
+          ) : null}
+          {isListOpen && filteredTasks.length > 0 ? (
+            <p aria-live="polite" className="traceability-task-pagination-status" role="status">
+              {isLoadingTasks
+                ? locale === "pt-BR"
+                  ? "Carregando mais tasks…"
+                  : "Loading more tasks…"
+                : hasMoreVisibleTasks || hasMoreTasks
+                  ? locale === "pt-BR"
+                    ? `${visibleTasks.length} de ${filteredTasks.length} tasks exibidas. Role para carregar mais.`
+                    : `${visibleTasks.length} of ${filteredTasks.length} tasks shown. Scroll to load more.`
+                  : locale === "pt-BR"
+                    ? `${filteredTasks.length} tasks exibidas. Fim da lista.`
+                    : `${filteredTasks.length} tasks shown. End of list.`}
+            </p>
           ) : null}
         </div>
         <small>

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

@@ -22,12 +22,17 @@ describe("Cost period refresh", () => {
       app.indexOf("const refresh = useCallback"),
       app.indexOf("const loadOperationsDetails"),
     );
+    const compactRefresh = refresh.replace(/\s+/g, " ");
 
     expect(refresh).not.toContain("dailyCostSeed(currency, period)");
     expect(refresh).toContain("initialAggregateFreshRef.current");
     expect(refresh).not.toContain("loadAtomicCostSnapshot(() => api.snapshot(currency, period))");
-    expect(refresh).toContain('api.operations(period, "quick", undefined, initialAggregateFreshRef.current)');
-    expect(refresh).toContain('currency === "USD" ? api.costMonitor(currency, period, "summary") : Promise.resolve(null)');
+    expect(refresh).toContain(
+      'api.operations(period, "quick", undefined, initialAggregateFreshRef.current)',
+    );
+    expect(compactRefresh).toContain(
+      'currency === "USD" ? api.costMonitor(currency, period, "summary") : Promise.resolve(null)',
+    );
     expect(refresh).toContain("setDisplayedCosts(null);");
     expect(refresh).toContain("const activeDashboardView = dashboardViewRef.current");
     expect(refresh).toContain("[api, currency, operationsPeriod]");
@@ -54,14 +59,24 @@ describe("Cost period refresh", () => {
     const loaders = readFileSync(new URL("./use-app-cost-loaders.ts", import.meta.url), "utf8");
     expect(app).toContain("useAppCostLoaders(api)");
     expect(loaders).toContain("const loadCostRunPage = useCallback<LoadCostRunPage>");
-    expect(loaders).toContain('api.sqliteViewPage("cost_monitor_agent_invocations"');
+    expect(loaders).toMatch(/api\.sqliteViewPage\(\s*"cost_monitor_agent_invocations"/);
     expect(loaders).toContain("const loadCostGroupPage = useCallback<LoadCostGroupPage>");
     expect(loaders).toContain("task_count: nullableSqlNumber(row.task_count)");
     expect(loaders).toContain("prd_count: Number(row.prd_count ?? 0)");
     expect(loaders).toContain("spec_count: Number(row.spec_count ?? 0)");
     expect(loaders).toContain("evidence_count: Number(row.evidence_count ?? 0)");
     expect(loaders).toContain("test_count: Number(row.validation_count ?? 0)");
-    for (const dimension of ["provider", "model", "agent", "phase", "status", "origin", "workType", "priority", "risk"])
+    for (const dimension of [
+      "provider",
+      "model",
+      "agent",
+      "phase",
+      "status",
+      "origin",
+      "workType",
+      "priority",
+      "risk",
+    ])
       expect(loaders).toContain(`filters.${dimension}`);
     expect(app).toContain("loadRunPage={loadCostRunPage}");
     expect(app).toContain("loadReadModelPage={loadCostReadModelPage}");

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.test.ts

@@ -21,7 +21,7 @@ describe("DashboardApiClient reconciliation", () => {
     vi.stubGlobal("fetch", fetchMock);
 
     const pending = new DashboardApiClient("session").reconcileOpenWork();
-    const rejection = expect(pending).rejects.toThrow("125 segundos");
+    const rejection = expect(pending).rejects.toThrow("180 segundos");
     await vi.advanceTimersByTimeAsync(30_000);
     expect(fetchMock.mock.calls[0]?.[1].signal?.aborted).toBe(false);
 
@@ -31,8 +31,14 @@ describe("DashboardApiClient reconciliation", () => {
 
   it("posts to the exact canonical reconciliation path without a trailing slash", async () => {
     vi.stubGlobal("window", globalThis);
-    const fetchMock = vi.fn(async () =>
-      new Response(JSON.stringify({ reconciliation: { reconciled_ids: [], blocked: [], not_reconciled: [] } }), { status: 200 }),
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            reconciliation: { reconciled_ids: [], blocked: [], not_reconciled: [] },
+          }),
+          { status: 200 },
+        ),
     );
     vi.stubGlobal("fetch", fetchMock);
 
@@ -46,6 +52,22 @@ describe("DashboardApiClient reconciliation", () => {
       expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
     );
   });
+
+  it("refreshes the disposable projection without calling the reconciliation route", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(async () => new Response(JSON.stringify({}), { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").refreshProjection("BRL", {
+      from: "2026-08-12",
+      to: "2026-08-12",
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v2/refresh-projection?currency=BRL&from=2026-08-12&to=2026-08-12",
+      expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
+    );
+  });
 });
 
 describe("DashboardApiClient cost monitor", () => {
@@ -94,6 +116,30 @@ describe("DashboardApiClient cost monitor", () => {
     expect(requestPath).not.toContain("run_kind=");
   });
 
+  it("sends the Work List stage through the canonical status query parameter", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string) =>
+      Promise.resolve(
+        new Response(JSON.stringify({ rows: [] }), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").sqliteViewPage("operations_work_list", undefined, {
+      limit: 10,
+      origin: "standalone",
+      status: "executing",
+    });
+
+    const requestPath = String(fetchMock.mock.calls[0]?.[0]);
+    expect(requestPath).toContain("status=executing");
+    expect(requestPath).toContain("origin=standalone");
+    expect(requestPath).not.toContain("stage=executing");
+  });
+
   it("adds fresh only to an explicit bootstrap aggregate read", async () => {
     vi.stubGlobal("window", globalThis);
     const fetchMock = vi.fn((_path: string | URL | Request) =>