@zaip-ai/cli 3.2.0 → 3.4.0

package/templates/.agents/dashboard/apps/frontend/src/app-work-board-options.ts

@@ -0,0 +1,41 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import type { Dispatch, RefObject, SetStateAction } from "react";
+import type {
+  BoardStageState,
+  OverviewClassificationPages,
+  OverviewStatusPages,
+} from "./AppWorkBoard.js";
+import type {
+  DashboardApiClient,
+  OperationsBoardPage,
+  OperationsPageFilters,
+  WorkBoardStage,
+} from "./dashboard-api.js";
+import type { OperationsPeriodState } from "./operations-period.js";
+
+type StateSetter<T> = Dispatch<SetStateAction<T>>;
+
+export interface AppWorkBoardOptions {
+  api: DashboardApiClient;
+  boardAbortControllersRef: RefObject<Map<WorkBoardStage, AbortController>>;
+  boardFilterKeyRef: RefObject<string>;
+  boardFiltersRef: RefObject<OperationsPageFilters>;
+  boardInFlightRef: RefObject<Set<WorkBoardStage>>;
+  boardInitialPageRef: RefObject<Set<WorkBoardStage>>;
+  boardLoadedRef: RefObject<Partial<Record<WorkBoardStage, number>>>;
+  boardRequestVersionRef: RefObject<number>;
+  dashboardView: "operations" | "cost-monitor" | "traceability" | null;
+  operations: OperationsProjection | null;
+  operationsPeriod: OperationsPeriodState;
+  operationsPeriodRef: RefObject<OperationsPeriodState>;
+  overviewStatusInFlightRef: RefObject<Set<string>>;
+  quickOverviewMetricsRef: RefObject<OperationsProjection["summary"]["overview_metrics"]>;
+  setBoardKindTotals: StateSetter<
+    Partial<Record<WorkBoardStage, OperationsBoardPage["totals_by_kind"]>>
+  >;
+  setBoardStates: StateSetter<Partial<Record<WorkBoardStage, BoardStageState>>>;
+  setBoardTotals: StateSetter<Partial<Record<WorkBoardStage, number>>>;
+  setOperations: StateSetter<OperationsProjection | null>;
+  setOverviewClassificationPages: StateSetter<OverviewClassificationPages>;
+  setOverviewStatusPages: StateSetter<OverviewStatusPages>;
+}

package/templates/.agents/dashboard/apps/frontend/src/dashboard-runtime-status.ts

@@ -0,0 +1,25 @@
+export interface DashboardRuntimeStatus {
+  workspace: string;
+  workspace_name: string;
+  workspaceKey: string;
+  status: "ok" | "degraded";
+  lifecycle_manifest_state: "initialized" | "missing" | "invalid";
+  active_capture_failure?: { code: string } | null;
+}
+
+export async function readDashboardRuntimeStatus(
+  signal: AbortSignal,
+): Promise<DashboardRuntimeStatus> {
+  const response = await fetch("/api/v2/health", { cache: "no-store", signal });
+  const value = await response.json();
+  // A degraded response is useful diagnostic data, including HTTP 503.
+  if (
+    value?.kind !== "zaip-dashboard-sqlite-runtime" ||
+    typeof value.workspace !== "string" ||
+    typeof value.workspace_name !== "string" ||
+    !["initialized", "missing", "invalid"].includes(value.lifecycle_manifest_state)
+  ) {
+    throw new Error("Identidade do Dashboard indisponível");
+  }
+  return value;
+}

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

@@ -334,8 +334,8 @@ describe("atomic Cost snapshot loading", () => {
     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).not.toContain("window.requestIdleCallback");
     expect(boardHydration).toContain("!boardInitialPageRef.current.has(stage)");
     expect(boardHydration).toContain("boardInitialPageRef.current.add(stage)");
     expect(boardHydration).toContain("!boardInFlightRef.current.has(stage)");

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

@@ -134,6 +134,10 @@ export async function loadSqliteCostRunPage(api: DashboardApiClient, request: Co
       ...(filters?.agent ? { agent: filters.agent } : {}),
       ...(filters?.phase ? { phase: filters.phase } : {}),
       ...(filters?.status ? { status: filters.status } : {}),
+      ...(filters?.priority ? { priority: filters.priority } : {}),
+      ...(filters?.risk ? { risk: filters.risk } : {}),
+      ...(filters?.origin ? { origin: filters.origin } : {}),
+      ...(filters?.workType ? { workType: filters.workType } : {}),
     },
     signal,
   );
@@ -360,7 +364,7 @@ export function useAppCostLoaders(api: DashboardApiClient) {
         {
           offset,
           limit,
-          ...(query === undefined || query === "" ? {} : { query }),
+          ...(filters.query || query ? { query: filters.query || query } : {}),
           ...(filters.provider ? { provider: filters.provider } : {}),
           ...(filters.model ? { model: filters.model } : {}),
           ...(filters.agent ? { agent: filters.agent } : {}),

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

@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import type { DashboardApiClient, OperationsPageFilters, WorkBoardStage } from "./dashboard-api.js";
+import type { OperationsPeriodState } from "./operations-period.js";
+import { useAppWorkBoard } from "./use-app-work-board.js";
+
+const effects = vi.hoisted(() => [] as Array<() => void | (() => void)>);
+
+// Exercise the hook's actual request and reset logic while retaining direct
+// control of the deferred effect callback that races with a filter reset.
+vi.mock("react", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("react")>()),
+  useCallback: <T>(callback: T) => callback,
+  useEffect: (effect: () => void | (() => void)) => effects.push(effect),
+}));
+
+const filters: OperationsPageFilters = {
+  query: "",
+  status: "",
+  risk: "",
+  origin: "",
+  kind: "",
+};
+const operationsPeriod: OperationsPeriodState = {
+  preset: "all",
+  range: { start: "2026-08-01", end: "2026-08-31" },
+};
+
+function boardPage(stage: WorkBoardStage) {
+  return {
+    stage,
+    offset: 0,
+    total: 0,
+    totals_by_kind: { all: 0, task: 0, "standalone-task": 0, prd: 0, spec: 0 },
+    prds: [],
+    specs: [],
+    tasks: [],
+    changes: [],
+  };
+}
+
+function setup() {
+  const operationsBoard = vi.fn<DashboardApiClient["operationsBoard"]>(async (_period, stage) =>
+    boardPage(stage),
+  );
+  const api = { operationsBoard } as unknown as DashboardApiClient;
+  let operations = {
+    prds: [],
+    specs: [],
+    tasks: [],
+    changes: [],
+    summary: {},
+  } as unknown as OperationsProjection;
+  const boardInitialPageRef = { current: new Set<WorkBoardStage>() };
+  const boardRequestVersionRef = { current: 0 };
+  const setOperations = (
+    update:
+      | OperationsProjection
+      | null
+      | ((current: OperationsProjection | null) => OperationsProjection | null),
+  ) => {
+    operations = (
+      typeof update === "function" ? update(operations) : update
+    ) as OperationsProjection;
+  };
+  const render = () =>
+    useAppWorkBoard({
+      api,
+      boardAbortControllersRef: { current: new Map() },
+      boardFilterKeyRef: { current: "||||" },
+      boardFiltersRef: { current: filters },
+      boardInFlightRef: { current: new Set() },
+      boardInitialPageRef,
+      boardLoadedRef: { current: {} },
+      boardRequestVersionRef,
+      dashboardView: "operations",
+      operations,
+      operationsPeriod,
+      operationsPeriodRef: { current: operationsPeriod },
+      overviewStatusInFlightRef: { current: new Set() },
+      quickOverviewMetricsRef: { current: undefined },
+      setBoardKindTotals: vi.fn() as never,
+      setBoardStates: vi.fn() as never,
+      setBoardTotals: vi.fn() as never,
+      setOperations,
+      setOverviewClassificationPages: vi.fn() as never,
+      setOverviewStatusPages: vi.fn() as never,
+    });
+  return { boardInitialPageRef, operationsBoard, render };
+}
+
+beforeEach(() => {
+  effects.length = 0;
+  vi.useFakeTimers();
+  vi.stubGlobal("window", { setTimeout, clearTimeout, requestIdleCallback: undefined });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+describe("work board hydration generation", () => {
+  it("hydrates the visible board when requestIdleCallback never runs", async () => {
+    const requestIdleCallback = vi.fn(() => 1);
+    vi.stubGlobal("window", {
+      setTimeout,
+      clearTimeout,
+      requestIdleCallback,
+      cancelIdleCallback: vi.fn(),
+    });
+    const { boardInitialPageRef, operationsBoard, render } = setup();
+    render();
+    const effect = effects[0];
+    if (effect === undefined) throw new Error("expected visible board hydration effect");
+    const cleanup = effect();
+
+    await vi.runAllTimersAsync();
+
+    expect(requestIdleCallback).not.toHaveBeenCalled();
+    expect(operationsBoard).toHaveBeenCalledTimes(9);
+    expect(boardInitialPageRef.current.size).toBe(9);
+    cleanup?.();
+  });
+
+  it("does not let an older scheduled callback consume the reset board generation", async () => {
+    const { boardInitialPageRef, operationsBoard, render } = setup();
+    const board = render();
+    const staleEffect = effects[0];
+    if (staleEffect === undefined) throw new Error("expected initial board hydration effect");
+    const cleanup = staleEffect();
+
+    board.loadFilteredBoard({ ...filters, kind: "task" });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(operationsBoard).not.toHaveBeenCalled();
+    expect(boardInitialPageRef.current).toEqual(new Set());
+    cleanup?.();
+  });
+});

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

@@ -1,25 +1,19 @@
-import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
-import { type Dispatch, type RefObject, type SetStateAction, useCallback, useEffect } from "react";
+import { useCallback, useEffect } from "react";
 import { isAbortError, mergeBoardPages } from "./AppRequestGuards.js";
 import {
-  type BoardStageState,
   initialWorkBoardStages,
   type OverviewClassification,
-  type OverviewClassificationPages,
   type OverviewStatusKind,
-  type OverviewStatusPages,
   overviewClassificationPageKey,
   overviewStatusPageKey,
 } from "./AppWorkBoard.js";
+import type { AppWorkBoardOptions } from "./app-work-board-options.js";
 import type {
-  DashboardApiClient,
   OperationsBoardPage,
   OperationsPageFilters,
   WorkBoardStage,
 } from "./dashboard-api.js";
-import { type OperationsPeriodState, requestPeriodForOperations } from "./operations-period.js";
-
-type StateSetter<T> = Dispatch<SetStateAction<T>>;
+import { requestPeriodForOperations } from "./operations-period.js";
 
 export function useAppWorkBoard({
   api,
@@ -42,30 +36,7 @@ export function useAppWorkBoard({
   setOperations,
   setOverviewClassificationPages,
   setOverviewStatusPages,
-}: {
-  api: DashboardApiClient;
-  boardAbortControllersRef: RefObject<Map<WorkBoardStage, AbortController>>;
-  boardFilterKeyRef: RefObject<string>;
-  boardFiltersRef: RefObject<OperationsPageFilters>;
-  boardInFlightRef: RefObject<Set<WorkBoardStage>>;
-  boardInitialPageRef: RefObject<Set<WorkBoardStage>>;
-  boardLoadedRef: RefObject<Partial<Record<WorkBoardStage, number>>>;
-  boardRequestVersionRef: RefObject<number>;
-  dashboardView: "operations" | "cost-monitor" | "traceability" | null;
-  operations: OperationsProjection | null;
-  operationsPeriod: OperationsPeriodState;
-  operationsPeriodRef: RefObject<OperationsPeriodState>;
-  overviewStatusInFlightRef: RefObject<Set<string>>;
-  quickOverviewMetricsRef: RefObject<OperationsProjection["summary"]["overview_metrics"]>;
-  setBoardKindTotals: StateSetter<
-    Partial<Record<WorkBoardStage, OperationsBoardPage["totals_by_kind"]>>
-  >;
-  setBoardStates: StateSetter<Partial<Record<WorkBoardStage, BoardStageState>>>;
-  setBoardTotals: StateSetter<Partial<Record<WorkBoardStage, number>>>;
-  setOperations: StateSetter<OperationsProjection | null>;
-  setOverviewClassificationPages: StateSetter<OverviewClassificationPages>;
-  setOverviewStatusPages: StateSetter<OverviewStatusPages>;
-}) {
+}: AppWorkBoardOptions) {
   const resetBoard = useCallback(() => {
     boardRequestVersionRef.current += 1;
     for (const controller of boardAbortControllersRef.current.values()) controller.abort();
@@ -365,26 +336,42 @@ export function useAppWorkBoard({
   useEffect(() => {
     if (dashboardView !== "operations" || operations === null) return;
     let cancelled = false;
+    // resetBoard invalidates an older filter generation before React has had
+    // a chance to run this effect's cleanup. Do not let that older idle
+    // callback mark stages as initialized: its responses are rejected by
+    // loadMoreBoard, and the new generation would otherwise never hydrate.
+    const hydrationRequestVersion = boardRequestVersionRef.current;
+    const isCurrentHydration = () =>
+      !cancelled && hydrationRequestVersion === boardRequestVersionRef.current;
     const hydrateBoard = async () => {
+      if (!isCurrentHydration()) return;
       const pending = initialWorkBoardStages.filter(
         (stage) => !boardInitialPageRef.current.has(stage) && !boardInFlightRef.current.has(stage),
       );
-      for (let offset = 0; offset < pending.length && !cancelled; offset += 3) {
+      for (let offset = 0; offset < pending.length && isCurrentHydration(); offset += 3) {
         const batch = pending.slice(offset, offset + 3);
+        if (!isCurrentHydration()) return;
         for (const stage of batch) boardInitialPageRef.current.add(stage);
         await Promise.all(batch.map((stage) => loadMoreBoard(stage)));
       }
     };
-    const idle =
-      typeof window.requestIdleCallback === "function"
-        ? { kind: "idle" as const, id: window.requestIdleCallback(() => void hydrateBoard()) }
-        : { kind: "timeout" as const, id: window.setTimeout(() => void hydrateBoard(), 0) };
+    // This board is the visible Operations surface. requestIdleCallback has
+    // no delivery deadline and can remain deferred during rapid interaction,
+    // leaving every cleared column empty despite a current API population.
+    // Schedule it after the current paint instead, with a cancellable timer.
+    const timer = window.setTimeout(() => void hydrateBoard(), 0);
     return () => {
       cancelled = true;
-      if (idle.kind === "idle") window.cancelIdleCallback(idle.id);
-      else window.clearTimeout(idle.id);
+      window.clearTimeout(timer);
     };
-  }, [boardInFlightRef, boardInitialPageRef, dashboardView, loadMoreBoard, operations]);
+  }, [
+    boardInFlightRef,
+    boardInitialPageRef,
+    boardRequestVersionRef,
+    dashboardView,
+    loadMoreBoard,
+    operations,
+  ]);
 
   return {
     boardExportSource,

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

@@ -0,0 +1,38 @@
+import { useEffect, useState } from "react";
+import {
+  type DashboardRuntimeStatus,
+  readDashboardRuntimeStatus,
+} from "./dashboard-runtime-status.js";
+
+export function useRuntimeStatus() {
+  const [status, setStatus] = useState<DashboardRuntimeStatus | null>(null);
+  const [unavailable, setUnavailable] = useState(false);
+  useEffect(() => {
+    let disposed = false;
+    let timer: ReturnType<typeof setTimeout>;
+    let controller: AbortController;
+    async function poll() {
+      controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 4000);
+      try {
+        const next = await readDashboardRuntimeStatus(controller.signal);
+        if (!disposed) {
+          setStatus(next);
+          setUnavailable(false);
+        }
+      } catch {
+        if (!disposed) setUnavailable(true);
+      } finally {
+        clearTimeout(timeout);
+        if (!disposed) timer = setTimeout(poll, 5000);
+      }
+    }
+    void poll();
+    return () => {
+      disposed = true;
+      clearTimeout(timer);
+      controller?.abort();
+    };
+  }, []);
+  return { status, unavailable };
+}

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

@@ -0,0 +1,33 @@
+.workspace-status {
+  position: sticky;
+  top: 0;
+  z-index: 61;
+  padding: 8px 24px;
+  background: var(--surface-muted, #111827);
+  color: var(--text, #f1f5f9);
+  border-bottom: 1px solid var(--border, rgba(255, 255, 255, 0.12));
+  font-size: 12px;
+}
+.dashboard-header {
+  top: var(--dashboard-workspace-height, 0px);
+}
+.workspace-status__identity {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 16px;
+  align-items: baseline;
+}
+.workspace-status__identity span {
+  overflow-wrap: anywhere;
+  min-width: 0;
+}
+.workspace-status__warning {
+  margin: 8px 0;
+  color: var(--error-text, #fecaca);
+}
+.workspace-status__warning p {
+  margin: 4px 0;
+}
+.workspace-status code {
+  overflow-wrap: anywhere;
+}

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

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

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CompactLifecycleCostTable.test.ts

@@ -44,7 +44,9 @@ describe("CompactLifecycleCostTable filtered subtotal", () => {
       },
     });
     const [table] = view.props.children as readonly {
-      props: { columns: Array<{ key: string; footer?: unknown }> };
+      props: {
+        columns: Array<{ key: string; footer?: unknown; render?: (row: unknown) => unknown }>;
+      };
     }[];
     expect(table).toBeDefined();
     const footer = (key: string) =>
@@ -56,9 +58,29 @@ describe("CompactLifecycleCostTable filtered subtotal", () => {
     expect(footer("tokens")).toBe("540");
     expect(footer("cost")).toContain("R$");
     expect(footer("cost")).not.toContain("US$");
+    const unknownRow = {
+      metrics: { duration: unavailable, total_tokens: known(15), cost: unavailable },
+    };
+    const render = (key: string) =>
+      table!.props.columns.find((column) => column.key === key)?.render?.(unknownRow);
+    expect(render("duration")).toBe("Indisponível");
+    expect(render("cost")).toBe("Indisponível");
+    expect(render("tokens")).toBe("15");
+    const partialRow = {
+      metrics: {
+        duration: { ...unavailable, known_sum: 1000, coverage_ratio: 0.5 },
+        cost: { ...unavailable, coverage_ratio: 0.5 },
+      },
+    };
+    expect(
+      table!.props.columns.find((column) => column.key === "duration")?.render?.(partialRow),
+    ).toBe("1 seg (parcial)");
+    expect(table!.props.columns.find((column) => column.key === "cost")?.render?.(partialRow)).toBe(
+      "0 (parcial)",
+    );
   });
 
-  it("renders unknown numeric subtotals as zero", () => {
+  it("distinguishes unavailable duration from observed zero subtotals", () => {
     const view = CompactLifecycleCostTable({
       locale: "pt-BR",
       rows: [],
@@ -91,7 +113,7 @@ describe("CompactLifecycleCostTable filtered subtotal", () => {
       table!.props.columns.find((column) => column.key === key)?.footer;
     expect(footer("runs")).toBe("0");
     expect(footer("tokens")).toBe("0");
-    expect(footer("duration")).toBe("0");
+    expect(footer("duration")).toBe("Indisponível");
   });
 
   it("does not render a subtotal row when all lifecycle metrics are unavailable", () => {

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CompactLifecycleCostTable.tsx

@@ -4,7 +4,6 @@ import {
   formatCurrency,
   formatDurationMs,
 } from "@zaip-ai/dashboard-ui";
-import { estimatedDurationMs } from "../duration-estimate.js";
 import type { CostLocale } from "./cost-monitor-copy.js";
 import { formatDateTime } from "./cost-table-presentation.js";
 
@@ -83,17 +82,23 @@ export function CompactLifecycleCostTable({
   onOpenTrace?: (id: string) => void;
 }) {
   const metric = (value: KnownMetric, format: (known: number) => string) => {
-    return format(value.known_sum ?? 0);
+    if (value.known_sum === 0 && !value.complete && value.coverage_ratio === 0)
+      return locale === "pt-BR" ? "Indisponível" : "Unavailable";
+    const formatted = format(value.known_sum ?? 0);
+    return value.complete
+      ? formatted
+      : `${formatted} (${locale === "pt-BR" ? "parcial" : "partial"})`;
   };
   const durationMetric = (row: CompactLifecycleCostRow) => {
-    const value = row.metrics.duration;
     const effective = compactLifecycleDurationMs(row);
-    if (effective === null || (value.unknown > 0 && effective === 0)) return "0";
-    return formatDurationMs(effective, locale);
+    if (effective === null) return locale === "pt-BR" ? "Indisponível" : "Unavailable";
+    return metric(row.metrics.duration, (value) =>
+      value === 0 ? "0" : formatDurationMs(value, locale),
+    );
   };
   const subtotalMetric = (value: KnownMetric, format: (known: number) => string) => {
     if (subtotal === null) return undefined;
-    return format(value.known_sum ?? 0);
+    return metric(value, format);
   };
   const subtotalMetricUnavailable = (value: KnownMetric) =>
     value.unknown > 0 && value.known_sum === 0;
@@ -210,24 +215,17 @@ export function CompactLifecycleCostTable({
 }
 
 export function compactLifecycleDurationMs(row: CompactLifecycleCostRow): number | null {
-  return withTokenBackedCompactDuration(row).metrics.duration.known_sum;
+  const duration = row.metrics.duration;
+  return duration.known_sum === 0 && !duration.complete && duration.coverage_ratio === 0
+    ? null
+    : duration.known_sum;
 }
 
 export function withTokenBackedCompactDuration(
   row: CompactLifecycleCostRow,
 ): CompactLifecycleCostRow {
-  const duration = row.metrics.duration;
-  const tokenTotal = row.metrics.total_tokens.known_sum;
-  if (tokenTotal <= 0 || duration.known_sum > 0) return row;
-  const durationMs = estimatedDurationMs(tokenTotal);
-  if (durationMs === null || durationMs <= 0) return row;
-  return {
-    ...row,
-    metrics: {
-      ...row.metrics,
-      duration: { known_sum: durationMs, unknown: 0, complete: true, coverage_ratio: 1 },
-    },
-  };
+  // Compatibility export: token volume does not establish observed elapsed time.
+  return row;
 }
 
 function CompactLifecyclePagination({