@zaip-ai/cli 1.3.0 → 1.3.2

package/templates/.agents/dashboard/apps/frontend/src/traceability-task-pagination.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import {
+  appendTraceabilityTaskPage,
+  nextTraceabilityVisibleCount,
+  traceabilityTaskPageSize,
+} from "./traceability-task-pagination.js";
+
+describe("traceability task pagination", () => {
+  it("advances offsets through the API total while preserving unique tasks", () => {
+    const task = (id: string) => ({ id, title: id }) as never;
+    const first = appendTraceabilityTaskPage({
+      cursor: { offset: 0, stageIndex: 0 },
+      page: { tasks: [task("TASK-1"), task("TASK-2")], total: 3 } as never,
+      tasks: [],
+    });
+    const second = appendTraceabilityTaskPage({
+      cursor: first.cursor,
+      page: { tasks: [task("TASK-2"), task("TASK-3")], total: 3 } as never,
+      tasks: first.tasks,
+    });
+
+    expect(first.cursor).toEqual({ offset: 2, stageIndex: 0 });
+    expect(second.cursor).toEqual({ offset: 0, stageIndex: 1 });
+    expect(second.tasks.map((item) => item.id)).toEqual(["TASK-1", "TASK-2", "TASK-3"]);
+  });
+
+  it("advances the rendered list by a deterministic concise batch", () => {
+    expect(traceabilityTaskPageSize).toBe(10);
+    expect(nextTraceabilityVisibleCount(12, 30, 12)).toBe(24);
+    expect(nextTraceabilityVisibleCount(24, 30, 12)).toBe(30);
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/traceability-task-pagination.ts

@@ -0,0 +1,36 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import type { OperationsBoardPage } from "./dashboard-api.js";
+
+/** The selector is a navigation aid, not a full task export. */
+export const traceabilityTaskPageSize = 10;
+
+export type TraceabilityTaskCursor = { offset: number; stageIndex: number };
+
+export function appendTraceabilityTaskPage({
+  cursor,
+  page,
+  tasks,
+}: {
+  cursor: TraceabilityTaskCursor;
+  page: OperationsBoardPage;
+  tasks: OperationsProjection["tasks"];
+}): { cursor: TraceabilityTaskCursor; tasks: OperationsProjection["tasks"] } {
+  const tasksById = new Map(tasks.map((task) => [task.id, task]));
+  for (const task of page.tasks) tasksById.set(task.id, task);
+  const nextOffset = cursor.offset + page.tasks.length;
+  return {
+    tasks: [...tasksById.values()],
+    cursor:
+      page.tasks.length === 0 || nextOffset >= page.total
+        ? { offset: 0, stageIndex: cursor.stageIndex + 1 }
+        : { ...cursor, offset: nextOffset },
+  };
+}
+
+export function nextTraceabilityVisibleCount(
+  visibleCount: number,
+  totalCount: number,
+  batchSize: number,
+): number {
+  return Math.min(totalCount, visibleCount + batchSize);
+}

package/templates/.agents/dashboard/apps/frontend/src/traceability-workspace.css

@@ -63,13 +63,17 @@
   outline: none;
   background: rgba(56, 189, 248, 0.15);
 }
-.traceability-task-results button small,
-.traceability-task-no-results {
+.traceability-task-no-results,
+.traceability-task-pagination-status {
   color: #a8b6c9;
 }
 .traceability-task-no-results {
   padding: 12px;
 }
+.traceability-task-pagination-status {
+  margin: 0;
+  font-size: 0.78rem;
+}
 .traceability-workspace > header small {
   max-width: 360px;
   color: #71829a;

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.test.ts

@@ -4,6 +4,7 @@ import {
   adaptSqliteCompactLifecyclePage,
   adaptSqliteCostRun,
   loadSqliteCostGroupPage,
+  loadSqliteCostRunPage,
 } from "./use-app-cost-loaders.js";
 
 describe("daily Cost Monitor continuous pagination", () => {
@@ -205,6 +206,53 @@ describe("adaptSqliteCostRun", () => {
   });
 });
 
+describe("agent invocation remote pagination", () => {
+  it("forwards the requested ten-row page instead of expanding it to one hundred", async () => {
+    const calls: Array<{ view: string; range: unknown; page: Record<string, unknown> }> = [];
+    const api = {
+      sqliteViewPage: async (view: string, range: unknown, page: Record<string, unknown>) => {
+        calls.push({ view, range, page });
+        return {
+          offset: 10,
+          limit: 10,
+          total_count: 24,
+          has_more: true,
+          rows: [],
+        };
+      },
+    };
+
+    const loaded = await loadSqliteCostRunPage(api as never, {
+      currency: "BRL",
+      from: "2026-08-01",
+      to: "2026-08-25",
+      offset: 10,
+      limit: 10,
+      filters: {
+        query: "agent-builder",
+        provider: "openai",
+        model: "",
+        agent: "",
+        phase: "",
+        status: "",
+        origin: "",
+        workType: "",
+        priority: "",
+        risk: "",
+      },
+    });
+
+    expect(calls).toEqual([
+      {
+        view: "cost_monitor_agent_invocations",
+        range: { from: "2026-08-01", to: "2026-08-25" },
+        page: { offset: 10, limit: 10, query: "agent-builder", provider: "openai" },
+      },
+    ]);
+    expect(loaded.run_page).toEqual({ offset: 10, limit: 10, total: 24, has_more: true });
+  });
+});
+
 describe("adaptSqliteCompactLifecyclePage", () => {
   it("keeps identical server subtotals on page two for all compact lifecycle views", () => {
     const sqlitePage = {

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.ts

@@ -17,6 +17,7 @@ import {
 } from "./sqlite-cost-adapters.js";
 
 type CostGroupLoadRequest = Parameters<LoadCostGroupPage>[0];
+type CostRunLoadRequest = Parameters<LoadCostRunPage>[0];
 
 function costGroupQueryOptions(request: CostGroupLoadRequest, offset: number, limit: number) {
   const { filters, query } = request;
@@ -114,6 +115,35 @@ export async function loadSqliteCostGroupPage(
   };
 }
 
+export async function loadSqliteCostRunPage(api: DashboardApiClient, request: CostRunLoadRequest) {
+  const { filters, from, limit = 10, offset, signal, to } = request;
+  const page = await api.sqliteViewPage(
+    "cost_monitor_agent_invocations",
+    from === undefined || to === undefined ? undefined : { from, to },
+    {
+      offset,
+      limit,
+      ...(filters?.query ? { query: filters.query } : {}),
+      ...(filters?.provider ? { provider: filters.provider } : {}),
+      ...(filters?.model ? { model: filters.model } : {}),
+      ...(filters?.agent ? { agent: filters.agent } : {}),
+      ...(filters?.phase ? { phase: filters.phase } : {}),
+      ...(filters?.status ? { status: filters.status } : {}),
+    },
+    signal,
+  );
+  return {
+    page_only: true as const,
+    runs: page.rows.map(adaptSqliteCostRun),
+    run_page: {
+      offset: page.offset,
+      limit: page.limit,
+      total: page.total_count,
+      has_more: page.has_more,
+    },
+  };
+}
+
 /** Adapts a sparse SQLite invocation row to the complete CostRunRow contract. */
 export function adaptSqliteCostRun(
   row: Record<string, unknown>,
@@ -343,33 +373,7 @@ export function useAppCostLoaders(api: DashboardApiClient) {
     [api],
   );
   const loadCostRunPage = useCallback<LoadCostRunPage>(
-    async ({ filters, from, offset, signal, to }) => {
-      const page = await api.sqliteViewPage(
-        "cost_monitor_agent_invocations",
-        from === undefined || to === undefined ? undefined : { from, to },
-        {
-          offset,
-          limit: 100,
-          ...(filters?.query ? { query: filters.query } : {}),
-          ...(filters?.provider ? { provider: filters.provider } : {}),
-          ...(filters?.model ? { model: filters.model } : {}),
-          ...(filters?.agent ? { agent: filters.agent } : {}),
-          ...(filters?.phase ? { phase: filters.phase } : {}),
-          ...(filters?.status ? { status: filters.status } : {}),
-        },
-        signal,
-      );
-      return {
-        page_only: true,
-        runs: page.rows.map(adaptSqliteCostRun),
-        run_page: {
-          offset: page.offset,
-          limit: page.limit,
-          total: page.total_count,
-          has_more: page.has_more,
-        },
-      };
-    },
+    (request) => loadSqliteCostRunPage(api, request),
     [api],
   );
   const loadCostGroupPage = useCallback<LoadCostGroupPage>(

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

@@ -39,11 +39,15 @@ export function useAppTraceDocuments({
   >(null);
   const documentRequestId = useRef(0);
   const traceRequestId = useRef(0);
+  const traceAbortController = useRef<AbortController | null>(null);
   const [traceLoadingTaskId, setTraceLoadingTaskId] = useState<string | null>(null);
   const [selectedTraceTaskId, setSelectedTraceTaskId] = useState("");
 
   async function openTrace(taskId: string) {
     const requestId = ++traceRequestId.current;
+    traceAbortController.current?.abort();
+    const controller = new AbortController();
+    traceAbortController.current = controller;
     setError(null);
     setFailedArea(null);
     setTrace(null);
@@ -51,7 +55,7 @@ export function useAppTraceDocuments({
     setLoadingArea("traceability");
     await new Promise<void>((resolveFrame) => window.requestAnimationFrame(() => resolveFrame()));
     try {
-      const loadedTrace = await api.taskTrace(taskId);
+      const loadedTrace = await api.taskTrace(taskId, controller.signal);
       if (traceRequestId.current !== requestId) return false;
       const cardTask =
         traceTasks.find((task) => task.id === taskId) ??
@@ -65,12 +69,14 @@ export function useAppTraceDocuments({
       });
       return true;
     } catch (cause) {
+      if (controller.signal.aborted) return false;
       if (traceRequestId.current !== requestId) return false;
       setError(cause instanceof Error ? cause.message : String(cause));
       setFailedArea("traceability");
       return false;
     } finally {
       if (traceRequestId.current === requestId) {
+        if (traceAbortController.current === controller) traceAbortController.current = null;
         setTraceLoadingTaskId(null);
         setLoadingArea((current) => (current === "traceability" ? null : current));
       }

package/templates/.agents/dashboard/apps/frontend/src/use-app-work-list-page.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DashboardApiClient } from "./dashboard-api.js";
+import type { OperationsPeriodState } from "./operations-period.js";
+import { useAppWorkListPage, type WorkListPageState } from "./use-app-work-list-page.js";
+
+// Keep the hook's actual async/request logic; only replace React's render storage.
+const storage = vi.hoisted(() => ({
+  refs: [] as { current: unknown }[],
+  cursor: 0,
+  page: undefined as WorkListPageState | undefined,
+}));
+
+vi.mock("react", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("react")>()),
+  useCallback: (callback: unknown) => callback,
+  useRef: (initial: unknown) => {
+    const index = storage.cursor++;
+    storage.refs[index] ??= { current: initial };
+    return storage.refs[index];
+  },
+  useState: (initial: WorkListPageState) => {
+    storage.page ??= initial;
+    return [
+      storage.page,
+      (update: WorkListPageState | ((previous: WorkListPageState) => WorkListPageState)) => {
+        storage.page = typeof update === "function" ? update(storage.page ?? initial) : update;
+      },
+    ];
+  },
+}));
+
+const filters = { query: "", status: "", risk: "" };
+const period: OperationsPeriodState = {
+  preset: "this-month",
+  range: { start: "2026-08-01", end: "2026-08-30" },
+};
+const result = (offset: number) => ({
+  data_source: "sqlite_read_model" as const,
+  view: "operations_work_list" as const,
+  offset,
+  limit: 10,
+  total_count: 30,
+  has_more: true,
+  rows: [{ id: `row-${offset}` }],
+});
+
+function deferred() {
+  let resolve!: (value: ReturnType<typeof result>) => void;
+  let reject!: (cause: Error) => void;
+  const promise = new Promise<ReturnType<typeof result>>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+
+function setup() {
+  const sqliteViewPage = vi.fn<DashboardApiClient["sqliteViewPage"]>();
+  sqliteViewPage.mockImplementation(async (_view, _period, options) =>
+    result(options?.offset ?? 0),
+  );
+  const api = { sqliteViewPage } as unknown as DashboardApiClient;
+  const operationsPeriodRef = { current: period };
+  const render = (nextPeriod = operationsPeriodRef.current) => {
+    storage.cursor = 0;
+    operationsPeriodRef.current = nextPeriod;
+    return useAppWorkListPage({ api, operationsPeriod: nextPeriod, operationsPeriodRef });
+  };
+  return { sqliteViewPage, render, page: render() };
+}
+
+beforeEach(() => {
+  storage.refs = [];
+  storage.cursor = 0;
+  storage.page = undefined;
+  vi.useFakeTimers();
+});
+afterEach(() => vi.useRealTimers());
+
+describe("work-list request ordering", () => {
+  it("keeps offset 10 when the pending filter timer fires after explicit navigation", async () => {
+    const { page, sqliteViewPage } = setup();
+    await page.loadWorkListPage(filters);
+    setTimeout(() => void page.loadWorkListFilters(filters), 180);
+    await vi.advanceTimersByTimeAsync(50);
+    await page.loadWorkListPage(filters, 10);
+    await vi.advanceTimersByTimeAsync(200);
+
+    expect(sqliteViewPage.mock.calls.map((call) => call[2]?.offset)).toEqual([0, 10]);
+    expect(storage.page).toMatchObject({ offset: 10, loading: false, error: null });
+  });
+
+  it("does not abort an in-flight page request when identical hydration arrives", async () => {
+    const { page, sqliteViewPage } = setup();
+    await page.loadWorkListPage(filters);
+    const secondPage = deferred();
+    sqliteViewPage.mockReturnValueOnce(secondPage.promise);
+    const pending = page.loadWorkListPage(filters, 10);
+    await page.loadWorkListFilters(filters);
+    expect(sqliteViewPage).toHaveBeenCalledTimes(2);
+    expect(sqliteViewPage.mock.calls[1]?.[3]?.aborted).toBe(false);
+    secondPage.resolve(result(10));
+    await pending;
+    expect(storage.page?.offset).toBe(10);
+  });
+
+  it("applies changed filters at offset 0 and retains the selected work kind", async () => {
+    const { page, sqliteViewPage } = setup();
+    await page.loadWorkListPage({ ...filters, kind: "task" }, 10);
+    await page.loadWorkListFilters({ ...filters, query: "telemetria", origin: "standalone" });
+    expect(sqliteViewPage.mock.calls[1]?.[2]).toMatchObject({
+      offset: 0,
+      kind: "task",
+      query: "telemetria",
+      origin: "standalone",
+    });
+    await page.loadWorkListFilters({ ...filters, query: "telemetria", origin: "standalone" });
+    expect(sqliteViewPage).toHaveBeenCalledTimes(2);
+  });
+
+  it("retains explicit same-filter reloads for type selection and List re-entry", async () => {
+    const { page, sqliteViewPage } = setup();
+    await page.loadWorkListPage(filters, 10);
+    await page.loadWorkListPage(filters, 0);
+    expect(sqliteViewPage.mock.calls.map((call) => call[2]?.offset)).toEqual([10, 0]);
+  });
+
+  it("allows hydration after a canceled timer, reset or period change", async () => {
+    const { page, render, sqliteViewPage } = setup();
+    const timer = setTimeout(() => void page.loadWorkListFilters(filters), 180);
+    clearTimeout(timer);
+    await vi.advanceTimersByTimeAsync(200);
+    await page.loadWorkListFilters(filters);
+    page.resetWorkListPage();
+    await page.loadWorkListFilters(filters);
+    await render({ ...period, preset: "all" }).loadWorkListFilters(filters);
+    expect(sqliteViewPage).toHaveBeenCalledTimes(3);
+    expect(sqliteViewPage.mock.calls[2]?.[1]).toEqual({ from: null, to: null });
+  });
+
+  it("retries the same filters after a current request failed", async () => {
+    const { page, sqliteViewPage } = setup();
+    sqliteViewPage.mockRejectedValueOnce(new Error("read failed"));
+    await page.loadWorkListFilters(filters);
+    expect(storage.page?.error).toBe("read failed");
+    await page.loadWorkListFilters(filters);
+    expect(sqliteViewPage).toHaveBeenCalledTimes(2);
+    expect(storage.page?.error).toBeNull();
+  });
+
+  it("does not clear the current identity when an older aborted request fails", async () => {
+    const { page, sqliteViewPage } = setup();
+    const old = deferred();
+    sqliteViewPage.mockReturnValueOnce(old.promise);
+    const pending = page.loadWorkListPage(filters);
+    await page.loadWorkListPage(filters, 10);
+    old.reject(new Error("late failure"));
+    await pending;
+    await page.loadWorkListFilters(filters);
+    expect(sqliteViewPage).toHaveBeenCalledTimes(2);
+    expect(storage.page).toMatchObject({ offset: 10, error: null });
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/use-app-work-list-page.ts

@@ -0,0 +1,136 @@
+import { type MutableRefObject, useCallback, useRef, useState } from "react";
+import type { DashboardApiClient, OperationsPageFilters } from "./dashboard-api.js";
+import { type OperationsPeriodState, requestPeriodForOperations } from "./operations-period.js";
+import {
+  shouldStartWorkListLoad,
+  type WorkListLoadIntent,
+  workListLoadKey,
+} from "./work-list-load-dedup.js";
+import { normalizeWorkListFilters } from "./work-list-pagination.js";
+
+export type WorkListTypeFilter = "all" | "task" | "standalone-task" | "prd" | "spec";
+export type WorkListPageState = {
+  offset: number;
+  limit: number;
+  total: number | null;
+  hasMore: boolean;
+  typeFilter: WorkListTypeFilter;
+  rows: readonly Record<string, unknown>[];
+  loading: boolean;
+  error: string | null;
+};
+
+const initialPage: WorkListPageState = {
+  offset: 0,
+  limit: 10,
+  total: null,
+  hasMore: false,
+  typeFilter: "all",
+  rows: [],
+  loading: false,
+  error: null,
+};
+
+/** Visual List is one bounded SQLite page; exports use their own full iterator. */
+export function useAppWorkListPage({
+  api,
+  operationsPeriod,
+  operationsPeriodRef,
+}: {
+  api: DashboardApiClient;
+  operationsPeriod: OperationsPeriodState;
+  operationsPeriodRef: MutableRefObject<OperationsPeriodState>;
+}) {
+  const [workListPage, setWorkListPage] = useState<WorkListPageState>(initialPage);
+  const filtersRef = useRef<OperationsPageFilters>({ query: "", status: "", risk: "" });
+  const abortRef = useRef<AbortController | null>(null);
+  const requestVersionRef = useRef(0);
+  const knownLoadKeyRef = useRef<string | null>(null);
+  const load = useCallback(
+    async (filters: OperationsPageFilters, offset = 0, intent: WorkListLoadIntent = "explicit") => {
+      const period = requestPeriodForOperations(operationsPeriod);
+      const normalizedFilters = normalizeWorkListFilters(filters, filtersRef.current);
+      const loadKey = workListLoadKey(normalizedFilters, period);
+      if (!shouldStartWorkListLoad(intent, loadKey, knownLoadKeyRef.current)) return;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const requestVersion = ++requestVersionRef.current;
+      filtersRef.current = normalizedFilters;
+      knownLoadKeyRef.current = loadKey;
+      const typeFilter = (normalizedFilters.kind || "all") as WorkListTypeFilter;
+      setWorkListPage((current) => ({
+        ...current,
+        offset,
+        typeFilter,
+        loading: true,
+        error: null,
+      }));
+      try {
+        const sql = await api.sqliteViewPage(
+          "operations_work_list",
+          period,
+          {
+            offset,
+            limit: 10,
+            ...(normalizedFilters.query ? { query: normalizedFilters.query } : {}),
+            ...(normalizedFilters.status ? { status: normalizedFilters.status } : {}),
+            ...(normalizedFilters.risk ? { risk: normalizedFilters.risk } : {}),
+            ...(normalizedFilters.origin ? { origin: normalizedFilters.origin } : {}),
+            ...(typeFilter === "all" ? {} : { kind: typeFilter }),
+          },
+          controller.signal,
+        );
+        if (
+          controller.signal.aborted ||
+          requestVersion !== requestVersionRef.current ||
+          period.from !== requestPeriodForOperations(operationsPeriodRef.current).from ||
+          period.to !== requestPeriodForOperations(operationsPeriodRef.current).to
+        )
+          return;
+        setWorkListPage({
+          offset: sql.offset,
+          limit: sql.limit,
+          total: sql.total_count,
+          hasMore: sql.has_more,
+          typeFilter,
+          rows: sql.rows,
+          loading: false,
+          error: null,
+        });
+      } catch (cause) {
+        if (controller.signal.aborted || requestVersion !== requestVersionRef.current) return;
+        if (knownLoadKeyRef.current === loadKey) knownLoadKeyRef.current = null;
+        setWorkListPage((current) => ({
+          ...current,
+          offset,
+          typeFilter,
+          loading: false,
+          error: cause instanceof Error ? cause.message : String(cause),
+        }));
+      } finally {
+        if (abortRef.current === controller) abortRef.current = null;
+      }
+    },
+    [api, operationsPeriod, operationsPeriodRef],
+  );
+  const reset = useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    ++requestVersionRef.current;
+    knownLoadKeyRef.current = null;
+    setWorkListPage(initialPage);
+  }, []);
+  const loadFilters = useCallback(
+    (filters: OperationsPageFilters) => load(filters, 0, "filter-hydration"),
+    [load],
+  );
+
+  return {
+    workListPage,
+    workListFiltersRef: filtersRef,
+    loadWorkListFilters: loadFilters,
+    loadWorkListPage: load,
+    resetWorkListPage: reset,
+  };
+}

package/templates/.agents/dashboard/apps/frontend/src/use-operations-detail-export.ts

@@ -0,0 +1,76 @@
+import { useCallback } from "react";
+import type { DashboardApiClient, SqliteViewName } from "./dashboard-api.js";
+import type { OperationsPeriodState } from "./operations-period.js";
+import { requestPeriodForOperations } from "./operations-period.js";
+import { allSqliteExportPages } from "./sqlite-page-export.js";
+
+export type OperationsExportView =
+  | "work-kanban"
+  | "work-list"
+  | "changes"
+  | "decisions"
+  | "executions"
+  | "runs"
+  | "conversations"
+  | "daily"
+  | "monthly"
+  | "yearly";
+
+type DetailExportFilters = {
+  query: string;
+  status: string;
+  risk: string;
+  origin: string;
+  kind?: string;
+};
+
+/** Exports are intentionally independent from the bounded visual page. */
+export function useOperationsDetailExport({
+  api,
+  operationsPeriod,
+}: {
+  api: DashboardApiClient;
+  operationsPeriod: OperationsPeriodState;
+}) {
+  return useCallback(
+    (view: OperationsExportView, filters: DetailExportFilters) => {
+      const period = requestPeriodForOperations(operationsPeriod);
+      if (view === "work-kanban") return undefined;
+      const sqliteView = {
+        "work-list": "operations_work_list",
+        changes: "operations_changes",
+        decisions: "operations_decisions",
+        executions: "operations_executions",
+        runs: "operations_agent_invocations",
+        conversations: "operations_conversations",
+        daily: "operations_daily",
+        monthly: "operations_monthly",
+        yearly: "operations_annual",
+      } as const satisfies Partial<Record<OperationsExportView, SqliteViewName>>;
+      const source = sqliteView[view];
+      if (source === undefined) return undefined;
+      const options = (offset: number) => ({
+        offset,
+        limit: 100,
+        ...(filters.query ? { query: filters.query } : {}),
+        ...(filters.status ? { status: filters.status } : {}),
+        ...(filters.risk ? { risk: filters.risk } : {}),
+        ...(filters.origin ? { origin: filters.origin } : {}),
+        ...(source === "operations_work_list" && filters.kind ? { kind: filters.kind } : {}),
+      });
+      return {
+        prepare: async () => {
+          const firstPage = await api.sqliteViewPage(source, period, options(0));
+          return {
+            totalRows: firstPage.total_count,
+            pages: () =>
+              allSqliteExportPages(firstPage, (offset) =>
+                api.sqliteViewPage(source, period, options(offset)),
+              ),
+          };
+        },
+      };
+    },
+    [api, operationsPeriod],
+  );
+}

package/templates/.agents/dashboard/apps/frontend/src/work-list-load-dedup.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { shouldStartWorkListLoad, workListLoadKey } from "./work-list-load-dedup.js";
+
+describe("work-list delayed filter hydration", () => {
+  const defaultFilters = { query: "", status: "", risk: "", origin: "", kind: "" };
+  const period = { from: "2026-08-01", to: "2026-08-31" };
+
+  it("keeps page two explicit while suppressing the same delayed hydration", () => {
+    const key = workListLoadKey(defaultFilters, period);
+
+    expect(shouldStartWorkListLoad("explicit", key, null)).toBe(true);
+    expect(shouldStartWorkListLoad("explicit", key, key)).toBe(true);
+    expect(shouldStartWorkListLoad("filter-hydration", key, key)).toBe(false);
+  });
+
+  it("rearms after cleanup when no matching request was started, and reloads real filter changes", () => {
+    const key = workListLoadKey(defaultFilters, period);
+    const changedKey = workListLoadKey({ ...defaultFilters, query: "telemetria" }, period);
+
+    expect(shouldStartWorkListLoad("filter-hydration", key, null)).toBe(true);
+    expect(shouldStartWorkListLoad("filter-hydration", changedKey, key)).toBe(true);
+  });
+});