@zaip-ai/cli 1.3.0 → 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") {
@@ -118,9 +124,12 @@ export function renderDashboardAlternateContent({
           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/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 = [
@@ -16,6 +20,15 @@ describe("TraceabilityWorkspace task search", () => {
     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");
 
@@ -26,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

@@ -2,9 +2,11 @@ import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contrac
 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";
@@ -68,17 +88,42 @@ export function TraceabilityWorkspace({
   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];
@@ -107,9 +152,16 @@ export function TraceabilityWorkspace({
             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"
@@ -120,10 +172,11 @@ export function TraceabilityWorkspace({
               aria-label={searchLabel}
               className="traceability-task-results"
               id={resultsId}
+              onScroll={loadMoreTasks}
               role="listbox"
             >
               {filteredTasks.length > 0 ? (
-                filteredTasks.map((task, index) => (
+                visibleTasks.map((task, index) => (
                   <div key={task.id} role="presentation">
                     <button
                       aria-selected={task.id === selectedTaskId}
@@ -134,7 +187,6 @@ export function TraceabilityWorkspace({
                       type="button"
                     >
                       <strong>{task.title}</strong>
-                      <small>{task.id}</small>
                     </button>
                   </div>
                 ))
@@ -145,6 +197,21 @@ export function TraceabilityWorkspace({
               )}
             </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>
           {locale === "pt-BR"

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);
 
@@ -116,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) =>

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

@@ -10,7 +10,6 @@ import type {
   TaskDetailProjection,
 } from "@zaip-ai/dashboard-operations/contracts";
 import type { TaskTrace } from "@zaip-ai/dashboard-traceability/contracts";
-
 export interface ReconciliationBlockedItem {
   id: string;
   reason: string | null;
@@ -56,7 +55,6 @@ export interface SqliteViewPage {
   totals?: Record<string, unknown>;
   rows: Array<Record<string, unknown>>;
 }
-
 export type OperationsScope = "quick" | "overview" | "detail";
 export type WorkBoardStage =
   | "definition"
@@ -252,6 +250,7 @@ export class DashboardApiClient {
       origin?: string;
       workType?: string;
       priority?: string;
+      kind?: string;
     } = {},
     signal?: AbortSignal,
   ): Promise<SqliteViewPage> {
@@ -267,6 +266,7 @@ export class DashboardApiClient {
     if (options.origin) query.set("origin", options.origin);
     if (options.workType) query.set("workType", options.workType);
     if (options.priority) query.set("priority", options.priority);
+    if (options.kind) query.set("kind", options.kind);
     return this.get(withPeriod(`/api/v2/sqlite-views?${query.toString()}`, period), signal);
   }
 
@@ -455,11 +455,9 @@ export class DashboardApiClient {
   spec(specId: string): Promise<SpecDetailProjection> {
     return this.get(dashboardApiPaths.spec(specId));
   }
-
-  taskTrace(taskId: string): Promise<TaskTrace> {
-    return this.get(dashboardApiPaths.taskTrace(taskId));
+  taskTrace(taskId: string, signal?: AbortSignal): Promise<TaskTrace> {
+    return this.get(dashboardApiPaths.taskTrace(taskId), signal);
   }
-
   pricing(): Promise<PricingCatalog> {
     return this.get("/api/v2/pricing");
   }
@@ -593,9 +591,9 @@ function operationsPageParams(
 }
 
 export const dashboardRequestTimeoutMs = 60_000;
-// The local runtime permits reconciliation for up to two minutes. Keep a small
-// transport margin so the browser never cancels a valid server-side operation.
-export const reconciliationRequestTimeoutMs = 125_000;
+// The command may use two minutes plus a projection rebuild; keep enough
+// transport margin to avoid false browser failures after healthy reconciliation.
+export const reconciliationRequestTimeoutMs = 180_000;
 
 export async function fetchWithTimeout(
   path: string,

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

@@ -94,12 +94,12 @@ describe("App-owned Operations period render", () => {
     expect(css).toContain("prefers-reduced-motion: reduce");
   });
 
-  it("uses the same global loading gate for snapshot, page, and board requests", () => {
+  it("reserves the global gate for a period replacement, not secondary pages", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     expect(app).toContain("const globalLoadingPending =");
-    expect(app).toContain("loadingArea !== null");
-    expect(app).toContain("entityPage.loading");
-    expect(app).toContain("Object.values(boardStates).some((state) => state.loading)");
+    expect(app).toContain("periodTransitionPending ||");
+    expect(app).not.toContain("entityPage.loading ||");
+    expect(app).not.toContain("Object.values(boardStates).some((state) => state.loading)");
     expect(app).toContain("<PeriodTransitionShell pending={globalLoadingPending}>");
   });
 });

package/templates/.agents/dashboard/apps/frontend/src/overview-status-page.test.ts

@@ -6,7 +6,7 @@ const source = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
 describe("overview status page loading", () => {
   it("requests a dedicated stage and kind page instead of reusing the mixed board page", () => {
     expect(source).toContain("const loadOverviewStatusPage");
-    expect(source).toContain("api.operationsBoard(period, stage, offset, { kind })");
+    expect(source).toContain('kind: kind === "task" ? "all-tasks" : kind');
     expect(source).toContain(
       'kind === "task" ? page.tasks : kind === "spec" ? page.specs : page.prds',
     );

package/templates/.agents/dashboard/apps/frontend/src/snapshot-banner-semantics.test.ts

@@ -44,6 +44,7 @@ describe("snapshot update banner semantics", () => {
   it("presents a stale local snapshot as neutral status and reserves alert red for errors", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     const boundary = readFileSync(new URL("./AppLoadingBoundary.tsx", import.meta.url), "utf8");
+    const overlays = readFileSync(new URL("./AppOverlays.tsx", import.meta.url), "utf8");
     const styles = readFileSync(new URL("./styles.css", import.meta.url), "utf8");
     const snapshot = app.slice(
       app.indexOf("const initialDataPending"),
@@ -70,7 +71,13 @@ describe("snapshot update banner semantics", () => {
     expect(error).toContain('aria-live="assertive"');
     expect(error).toContain('"Fechar erro"');
     expect(error).toContain('"Dismiss error"');
+    expect(overlays).not.toContain('role="alert"');
+    expect(overlays).not.toContain('className="app-warning"');
+    expect(overlays).not.toContain("startupReconciliation");
+    expect(overlays).not.toContain('"Fechar aviso de reconciliação"');
+    expect(overlays).not.toContain('"Dismiss reconciliation notice"');
     expect(styles).toContain(".app-snapshot-status {");
+    expect(styles).toContain(".app-refresh-status-close {");
     expect(styles).toContain("background: rgba(8, 47, 73, 0.96);");
     expect(styles).toContain(".app-warning.app-error {");
     expect(styles).toContain("background: rgba(69, 16, 16, 0.96);");

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

@@ -48,15 +48,18 @@ describe("atomic Cost snapshot loading", () => {
     expect(costSelection).not.toContain("loadOperationsDetails");
   });
 
-  it("opens the global overlay while the Cost page loads a selected group", () => {
+  it("never blocks the dashboard or starts a full snapshot for a paged Cost request", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     const globalGate = app.slice(
       app.indexOf("const globalLoadingPending"),
       app.indexOf("const renderedOperations"),
     );
-    expect(app).toContain("const [costSurfaceLoading, setCostSurfaceLoading] = useState(false);");
-    expect(globalGate).toContain("costSurfaceLoading");
-    expect(globalGate).toContain('loadingArea !== "costs"');
+    expect(app).toContain("const [, setCostSurfaceLoading] = useState(false);");
+    expect(globalGate).not.toContain("costSurfaceLoading");
+    expect(globalGate).not.toContain("operationsSurfaceLoading");
+    expect(globalGate).not.toContain("entityPage.loading");
+    expect(app).not.toContain("api.snapshot(currency, period)");
+    expect(app).not.toContain("useIdleCostPrefetch");
   });
 
   it("does not request Cost Monitor while the initial route is Operations", () => {
@@ -132,6 +135,12 @@ describe("atomic Cost snapshot loading", () => {
     expect(effects).toContain("void refresh(false, false, true)");
   });
 
+  it("does not reconcile open work automatically", () => {
+    const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
+    expect(app).not.toContain("startupReconciliation");
+    expect(app).toContain("await refresh(false, reconcileOpenWork, !reconcileOpenWork)");
+  });
+
   it("removes the global Cost detail request and keeps stale request guards", () => {
     const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
     const costPage = readFileSync(
@@ -231,13 +240,16 @@ describe("atomic Cost snapshot loading", () => {
       app.indexOf("const loadCostDetails"),
     );
 
-    expect(boardHydration).toContain("for (const stage of initialWorkBoardStages)");
-    expect(boardHydration).toContain("window.requestIdleCallback(hydrateBoard)");
-    expect(boardHydration).toContain("window.setTimeout(hydrateBoard, 0)");
+    expect(boardHydration).toContain("offset += 3");
+    expect(boardHydration).toContain(
+      "await Promise.all(batch.map((stage) => loadMoreBoard(stage)))",
+    );
+    expect(boardHydration).toContain("window.requestIdleCallback(() => void hydrateBoard())");
+    expect(boardHydration).toContain("window.setTimeout(() => void hydrateBoard(), 0)");
     expect(boardHydration).toContain("!boardInitialPageRef.current.has(stage)");
     expect(boardHydration).toContain("boardInitialPageRef.current.add(stage)");
     expect(boardHydration).toContain("!boardInFlightRef.current.has(stage)");
-    expect(boardHydration).toContain("void loadMoreBoard(stage)");
+    expect(boardHydration).toContain("boardInitialPageRef.current.add(stage)");
   });
 
   it("merges concurrent board pages without replacing rows from another stage", () => {

package/templates/.agents/dashboard/apps/frontend/src/sqlite-page-export.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from "vitest";
+import { allSqliteExportPages } from "./sqlite-page-export.js";
+
+describe("complete SQLite export", () => {
+  it("exports every filtered page, even when the visual page contains only ten rows", async () => {
+    const second = vi.fn().mockResolvedValue({
+      offset: 100,
+      total_count: 145,
+      has_more: false,
+      rows: Array.from({ length: 45 }, (_, id) => ({ id: `standalone-${id}` })),
+    });
+    const first = {
+      offset: 0,
+      total_count: 145,
+      has_more: true,
+      rows: Array.from({ length: 100 }, (_, id) => ({ id: `standalone-${id}` })),
+    };
+    const pages = [] as Array<readonly { id: string }[]>;
+    for await (const page of allSqliteExportPages(first, second)) pages.push(page);
+
+    expect(pages.flat()).toHaveLength(145);
+    expect(second).toHaveBeenCalledWith(100);
+  });
+
+  it("keeps the active PRD or standalone-task kind in the export source", async () => {
+    const source = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./use-operations-detail-export.ts", import.meta.url), "utf8"),
+    );
+    expect(source).toContain('source === "operations_work_list" && filters.kind');
+    expect(source).toContain("limit: 100");
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/sqlite-page-export.ts

@@ -0,0 +1,21 @@
+export type SqliteExportPage<Row extends Record<string, unknown>> = {
+  offset: number;
+  total_count: number;
+  has_more: boolean;
+  rows: readonly Row[];
+};
+
+/** Export transport deliberately follows every server page, unlike the UI. */
+export async function* allSqliteExportPages<Row extends Record<string, unknown>>(
+  firstPage: SqliteExportPage<Row>,
+  loadPage: (offset: number) => Promise<SqliteExportPage<Row>>,
+): AsyncGenerator<readonly Row[]> {
+  let page = firstPage;
+  while (true) {
+    if (page.rows.length === 0) return;
+    yield page.rows;
+    const nextOffset = page.offset + page.rows.length;
+    if (!page.has_more || nextOffset >= page.total_count) return;
+    page = await loadPage(nextOffset);
+  }
+}

package/templates/.agents/dashboard/apps/frontend/src/styles.css

@@ -438,6 +438,25 @@ select:focus-visible {
   font-size: 0.78rem;
 }
 
+.app-refresh-status-close {
+  flex: 0 0 auto;
+  align-self: flex-start;
+  border: 0;
+  border-radius: 6px;
+  padding: 0 5px;
+  color: #cbd5e1;
+  background: transparent;
+  cursor: pointer;
+  font-size: 1.25rem;
+  line-height: 1;
+}
+
+.app-refresh-status-close:hover,
+.app-refresh-status-close:focus-visible {
+  color: #f8fafc;
+  background: rgba(148, 163, 184, 0.16);
+}
+
 .app-reconciliation-result {
   position: fixed;
   z-index: 80;