@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/apps/frontend/src/use-app-operations-pages.ts

@@ -153,8 +153,7 @@ export function useAppOperationsPages({
               typeof row.source_duration_ms === "number" ? row.source_duration_ms : null,
             duration_provenance:
               typeof row.duration_provenance === "string" ? row.duration_provenance : null,
-            llm_call_count:
-              typeof row.llm_call_count === "number" ? row.llm_call_count : null,
+            llm_call_count: typeof row.llm_call_count === "number" ? row.llm_call_count : null,
             input_tokens: typeof row.input_tokens === "number" ? row.input_tokens : null,
             cached_input_tokens:
               typeof row.cached_input_tokens === "number" ? row.cached_input_tokens : null,
@@ -198,12 +197,10 @@ export function useAppOperationsPages({
               typeof row.standard_cost_usd === "number" ? row.standard_cost_usd : null,
             speed_uplift_usd:
               typeof row.speed_uplift_usd === "number" ? row.speed_uplift_usd : null,
-            input_cost_usd:
-              typeof row.input_cost_usd === "number" ? row.input_cost_usd : null,
+            input_cost_usd: typeof row.input_cost_usd === "number" ? row.input_cost_usd : null,
             cached_input_cost_usd:
               typeof row.cached_input_cost_usd === "number" ? row.cached_input_cost_usd : null,
-            output_cost_usd:
-              typeof row.output_cost_usd === "number" ? row.output_cost_usd : null,
+            output_cost_usd: typeof row.output_cost_usd === "number" ? row.output_cost_usd : null,
             reasoning_cost_usd:
               typeof row.reasoning_cost_usd === "number" ? row.reasoning_cost_usd : null,
             calculated_cost_usd:

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);
+  });
+});

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

@@ -0,0 +1,27 @@
+import type { OperationsPageFilters } from "./dashboard-api.js";
+
+export type WorkListLoadIntent = "explicit" | "filter-hydration";
+
+export function workListLoadKey(
+  filters: OperationsPageFilters,
+  period: { from: string | null; to: string | null },
+): string {
+  return JSON.stringify([
+    filters.query,
+    filters.status,
+    filters.risk,
+    filters.origin ?? "",
+    filters.kind ?? "",
+    period.from ?? "",
+    period.to ?? "",
+  ]);
+}
+
+/** Explicit type/reentry/page loads must remain actionable; delayed hydration is idempotent. */
+export function shouldStartWorkListLoad(
+  intent: WorkListLoadIntent,
+  key: string,
+  knownKey: string | null,
+): boolean {
+  return intent === "explicit" || key !== knownKey;
+}

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

@@ -1,15 +1,12 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-  collectWorkListPages,
-  normalizeWorkListFilters,
-  selectedWorkListKinds,
-} from "./work-list-pagination.js";
+import { describe, expect, it } from "vitest";
+import { normalizeWorkListFilters, selectedWorkListKinds } from "./work-list-pagination.js";
 
 describe("Trabalho (Lista) canonical pagination", () => {
   it("keeps a server-selected PRD/SPEC kind instead of refetching every kind", () => {
     expect(selectedWorkListKinds("spec")).toEqual(["spec"]);
     expect(selectedWorkListKinds("prd")).toEqual(["prd"]);
-    expect(selectedWorkListKinds("")).toEqual(["prd", "spec", "task"]);
+    expect(selectedWorkListKinds("standalone-task")).toEqual(["standalone-task"]);
+    expect(selectedWorkListKinds("")).toEqual(["prd", "spec", "task", "standalone-task"]);
   });
 
   it("retains the List type through search/status changes without mutating the Kanban snapshot", () => {
@@ -32,15 +29,42 @@ describe("Trabalho (Lista) canonical pagination", () => {
     expect(kanban).toEqual({ query: "kanban", status: "ready", risk: "", kind: "" });
   });
 
+  it("retains the active origin for the paginated List request and export", async () => {
+    const selected = normalizeWorkListFilters(
+      { query: "", status: "", risk: "", origin: "standalone", kind: "standalone-task" },
+      { query: "", status: "", risk: "", origin: "", kind: "" },
+    );
+    const loader = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./use-app-work-list-page.ts", import.meta.url), "utf8"),
+    );
+    const exportSource = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./use-operations-detail-export.ts", import.meta.url), "utf8"),
+    );
+
+    expect(selected.origin).toBe("standalone");
+    expect(loader).toContain(
+      "...(normalizedFilters.origin ? { origin: normalizedFilters.origin } : {})",
+    );
+    expect(loader).toContain("{ status: normalizedFilters.status }");
+    expect(exportSource).toContain("...(filters.origin ? { origin: filters.origin } : {})");
+    expect(exportSource).toContain("...(filters.status ? { status: filters.status } : {})");
+  });
 
-  it("continues from the returned offset until the canonical total is complete", async () => {
-    const loadPage = vi
-      .fn()
-      .mockResolvedValueOnce({ total: 59, received: 50, value: "first" })
-      .mockResolvedValueOnce({ total: 59, received: 9, value: "second" });
+  it("uses one bounded SQLite page for visual List loading", async () => {
+    const loader = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(new URL("./use-app-work-list-page.ts", import.meta.url), "utf8"),
+    );
+    const list = await import("node:fs/promises").then(({ readFile }) =>
+      readFile(
+        new URL("../../../modules/operations/src/react/PagedWorkList.tsx", import.meta.url),
+        "utf8",
+      ),
+    );
 
-    await expect(collectWorkListPages(loadPage)).resolves.toEqual(["first", "second"]);
-    expect(loadPage).toHaveBeenNthCalledWith(1, 0);
-    expect(loadPage).toHaveBeenNthCalledWith(2, 50);
+    expect(loader).toContain('"operations_work_list"');
+    expect(loader).toContain("limit: 10");
+    expect(loader).not.toContain("collectWorkListPages");
+    expect(loader).not.toContain("Promise.all(");
+    expect(list).toContain("row.kind ?? row.entity_kind");
   });
 });

package/templates/.agents/dashboard/apps/frontend/src/work-list-pagination.ts

@@ -1,4 +1,4 @@
-export type WorkListKind = "prd" | "spec" | "task";
+export type WorkListKind = "prd" | "spec" | "task" | "standalone-task";
 
 export type WorkListFilters = {
   query: string;
@@ -16,11 +16,10 @@ export function normalizeWorkListFilters(
   return { ...filters, kind: filters.kind ?? previous.kind ?? "" };
 }
 
-
 export function selectedWorkListKinds(kind: string | undefined): readonly WorkListKind[] {
-  return kind === "prd" || kind === "spec" || kind === "task"
+  return kind === "prd" || kind === "spec" || kind === "task" || kind === "standalone-task"
     ? [kind]
-    : ["prd", "spec", "task"];
+    : ["prd", "spec", "task", "standalone-task"];
 }
 
 export async function collectWorkListPages<T>(

package/templates/.agents/dashboard/apps/frontend/vite.config.ts

@@ -61,7 +61,10 @@ export default defineConfig({
           if (normalized.includes("/modules/cost-monitor/")) return "cost-monitor";
           if (normalized.includes("/modules/operations/")) return "operations";
           if (normalized.includes("/modules/traceability/")) return "traceability";
-          if (id.includes("node_modules/.pnpm/react@") || id.includes("node_modules/.pnpm/react-dom@"))
+          if (
+            id.includes("node_modules/.pnpm/react@") ||
+            id.includes("node_modules/.pnpm/react-dom@")
+          )
             return "react-vendor";
           if (id.includes("node_modules/.pnpm/lucide-react@")) return "icons-vendor";
           return undefined;

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

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