@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/operations/src/react/execution-metrics.ts

@@ -22,12 +22,14 @@ export interface ExecutionMetricRun {
 export function executionMetricRuns<T extends ExecutionMetricRun>(runs: readonly T[]): T[] {
   const unique = new Map<string, T>();
   for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  // Operations reports the elapsed work owned by a top-level Execution. A
+  // delegated Sub-Run is a separate Cost invocation, but including it here
+  // would make Operations double count work already represented by its root.
+  // `undefined` remains compatible with legacy root records.
   return [...unique.values()].filter(
     (run) =>
       (run.phase === undefined || run.phase === "execution") &&
-      (run.parent_run_id === null ||
-        run.parent_run_id === undefined ||
-        !unique.has(run.parent_run_id)),
+      (run.parent_run_id === undefined || run.parent_run_id === null),
   );
 }
 
@@ -76,7 +78,7 @@ export function globalLegacyEffortMetricDuration<T extends ExecutionMetricRun>(r
   return globalLegacyEffortDurationMs(runs, analyticalDuration);
 }
 
-/** Shared analytical total: every deduplicated observed execution Run, including Sub-Runs. */
+/** Shared analytical total: observed root execution duration only. */
 export function operationalRootExecutionDuration<T extends ExecutionMetricRun>(runs: readonly T[]) {
   return executionMetricTotals(runs).durationMs;
 }

package/templates/.agents/dashboard/modules/operations/src/react/export/ExcelExportAction.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { EXPORT_SUCCESS_TOAST_MS, exportRowsWithDurationHours } from "./ExcelExportAction.js";
+import {
+  EXPORT_SUCCESS_TOAST_MS,
+  KANBAN_EXPORT_COLUMNS,
+  exportPageSourceRows,
+  exportRowsWithDurationHours,
+} from "./ExcelExportAction.js";
 
 describe("ExcelExportAction duration mapper", () => {
   it("exports millisecond durations as unrounded numeric base hours with explicit hour headers", () => {
@@ -23,10 +28,54 @@ describe("ExcelExportAction duration mapper", () => {
   });
 });
 
+it("exports every paginated row once instead of only the visible page", async () => {
+  const exported: Record<string, unknown>[] = [];
+  for await (const page of exportPageSourceRows({
+    totalRows: 3,
+    pages: async function* () {
+      yield [
+        { id: "A", duration_ms: 3_600_000 },
+        { id: "B", duration_ms: 7_200_000 },
+      ];
+      yield [
+        { id: "B", duration_ms: 7_200_000 },
+        { id: "C", duration_ms: 10_800_000 },
+      ];
+    },
+  }))
+    exported.push(...page);
+
+  expect(exported).toEqual([
+    { id: "A", duration_hours: 1 },
+    { id: "B", duration_hours: 2 },
+    { id: "C", duration_hours: 3 },
+  ]);
+});
+
 it("keeps success feedback duration at four seconds", () => {
   expect(EXPORT_SUCCESS_TOAST_MS).toBe(4_000);
 });
 
+it("uses a prepared total when rows continue beyond the visible first fold", async () => {
+  const prepared = {
+    totalRows: 3,
+    pages: async function* () {
+      yield [{ id: "first" }];
+      yield [{ id: "beyond-first-fold" }, { id: "last" }];
+    },
+  };
+  const rows: Record<string, unknown>[] = [];
+  for await (const page of exportPageSourceRows(prepared)) rows.push(...page);
+  expect(rows.map((row) => row.id)).toEqual(["first", "beyond-first-fold", "last"]);
+  expect(prepared.totalRows).toBe(3);
+});
+
+it("keeps the complete Kanban schema when the visible page has only tasks", () => {
+  expect(KANBAN_EXPORT_COLUMNS).toEqual(
+    expect.arrayContaining(["kind", "id", "lifecycle_status", "status", "task_ids", "spec_id"]),
+  );
+});
+
 it("clears pending success when a new export starts", () => {
   expect("running").not.toBe("completed");
 });

package/templates/.agents/dashboard/modules/operations/src/react/export/ExcelExportAction.tsx

@@ -8,15 +8,89 @@ export type ExcelExportInput = {
   view: string;
   filters: Readonly<Record<string, unknown>>;
   rows: readonly Record<string, unknown>[];
+  pageSource?: PreparedExportPageSource | {
+    prepare: () => Promise<PreparedExportPageSource>;
+  } | undefined;
+};
+export type PreparedExportPageSource = {
+  totalRows: number;
+  pages: () => AsyncGenerator<readonly Record<string, unknown>[]>;
 };
 export const EXPORT_SUCCESS_TOAST_MS = 4_000;
 
+export const PERIOD_EXPORT_COLUMNS = [
+  "key",
+  "prds",
+  "specs",
+  "tasks",
+  "runs",
+  "tests",
+  "evidences",
+  "tokens",
+  "cost",
+  "duration_hours",
+] as const;
+
+// Board pages contain three canonical entity shapes. Keep their full common
+// schema even when the visible first page happens not to contain one shape.
+export const KANBAN_EXPORT_COLUMNS = [
+  "kind",
+  "id",
+  "title",
+  "short_name",
+  "objective",
+  "lifecycle_status",
+  "work_status",
+  "status",
+  "risk",
+  "priority",
+  "owner",
+  "created_at",
+  "updated_at",
+  "started_at",
+  "finished_at",
+  "parent_id",
+  "spec_id",
+  "change_id",
+  "manual_order",
+  "attempt_count",
+  "progress",
+  "is_active",
+  "artifact_path",
+  "requirement_ids",
+  "acceptance_ids",
+  "depends_on",
+  "write_scopes",
+  "task_ids",
+  "execution_ids",
+  "run_ids",
+  "duration_hours",
+  "duration_provenance",
+  "total_tokens",
+  "cost_brl",
+] as const;
+
+export async function* exportPageSourceRows(
+  pageSource: PreparedExportPageSource,
+): AsyncGenerator<Record<string, unknown>[]> {
+  const seen = new Set<string>();
+  for await (const page of pageSource.pages()) {
+    const unique = page.filter((row) => {
+      const id = typeof row.id === "string" ? row.id : JSON.stringify(row);
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    });
+    if (unique.length > 0) yield exportRowsWithDurationHours(unique);
+  }
+}
+
 export function exportRowsWithDurationHours(
   rows: readonly Record<string, unknown>[],
 ): Record<string, unknown>[] {
   return rows.map((row) =>
     Object.fromEntries(
-      Object.entries(row).map(([key, value]) => {
+      orderedExportEntries(row).map(([key, value]) => {
         const durationKey = durationHoursKey(key);
         if (durationKey === null)
           return [key, value !== null && typeof value === "object" ? JSON.stringify(value) : value];
@@ -26,6 +100,36 @@ export function exportRowsWithDurationHours(
   );
 }
 
+function orderedExportEntries(row: Record<string, unknown>): [string, unknown][] {
+  const normalized = normalizePeriodRow(row);
+  const keys = Object.keys(normalized);
+  const isPeriodRow = PERIOD_EXPORT_COLUMNS.some((key) => keys.includes(key));
+  if (!isPeriodRow) return Object.entries(row);
+  const ordered = PERIOD_EXPORT_COLUMNS.filter((key) => keys.includes(key)).map(
+    (key) => [key, normalized[key]] as [string, unknown],
+  );
+  return ordered;
+}
+
+function normalizePeriodRow(row: Record<string, unknown>): Record<string, unknown> {
+  if (Object.keys(row).some((key) => key !== "key" && PERIOD_EXPORT_COLUMNS.includes(key as never)))
+    return row;
+  if (!("prd_count" in row || "spec_count" in row || "run_count" in row)) return row;
+  return {
+    key: row.key,
+    prds: row.prd_count,
+    specs: row.spec_count,
+    tasks: row.task_count,
+    runs: row.run_count,
+    tests: row.test_count,
+    evidences: row.evidence_count,
+    duration_hours:
+      typeof row.duration_ms === "number" ? row.duration_ms / 3_600_000 : row.duration_ms,
+    tokens: row.total_tokens,
+    cost: row.estimated_brl,
+  };
+}
+
 function durationHoursKey(key: string): string | null {
   if (key === "durationMs") return "durationHours";
   if (key.endsWith("DurationMs")) return `${key.slice(0, -2)}Hours`;
@@ -33,11 +137,13 @@ function durationHoursKey(key: string): string | null {
   return key.endsWith("_duration_ms") ? `${key.slice(0, -2)}hours` : null;
 }
 
-export function ExcelExportAction({ filters, rows, view }: ExcelExportInput) {
+export function ExcelExportAction({ filters, pageSource, rows, view }: ExcelExportInput) {
   const controller = useRef<ExportController | null>(null);
   if (controller.current === null) controller.current = new ExportController();
   const [state, setState] = useState<ExportState>(controller.current.state);
   const [showSuccess, setShowSuccess] = useState(false);
+  const [preparing, setPreparing] = useState(false);
+  const [preflightError, setPreflightError] = useState<string | null>(null);
   useEffect(() => controller.current?.subscribe(setState), []);
   useEffect(() => {
     if (state.status !== "completed") {
@@ -50,8 +156,12 @@ export function ExcelExportAction({ filters, rows, view }: ExcelExportInput) {
   }, [state.status]);
   const headers: string[] = [];
   const headerSet = new Set<string>();
+  const isPeriodView = /-(daily|monthly|annual|yearly)$/.test(view);
+  if (isPeriodView) headers.push(...PERIOD_EXPORT_COLUMNS);
+  if (pageSource !== undefined && /work-kanban$/.test(view)) headers.push(...KANBAN_EXPORT_COLUMNS);
+  for (const key of headers) headerSet.add(key);
   for (const row of rows)
-    for (const key of Object.keys(row)) {
+    for (const [key] of orderedExportEntries(row)) {
       const header = durationHoursKey(key) ?? key;
       if (!headerSet.has(header)) {
         headerSet.add(header);
@@ -59,35 +169,59 @@ export function ExcelExportAction({ filters, rows, view }: ExcelExportInput) {
       }
     }
   if (headers.length === 0) headers.push("result");
-  const start = () => {
-    const snapshot = createExportSnapshot({
+  const createSnapshot = async () => {
+    const preparedPageSource =
+      pageSource === undefined
+        ? undefined
+        : "prepare" in pageSource
+          ? await pageSource.prepare()
+          : pageSource;
+    return createExportSnapshot({
       id: globalThis.crypto?.randomUUID?.() ?? `export-${Date.now()}`,
       createdAt: new Date().toISOString(),
       view,
       filters,
-      totalRows: rows.length,
+      totalRows: preparedPageSource?.totalRows ?? rows.length,
       pages: async function* () {
+        if (preparedPageSource !== undefined) {
+          yield* exportPageSourceRows(preparedPageSource);
+          return;
+        }
         for (let offset = 0; offset < rows.length; offset += 500)
           yield exportRowsWithDurationHours(rows.slice(offset, offset + 500));
       },
     });
-    void controller.current?.start({ snapshot, headers, view }).catch(() => undefined);
+  };
+  const start = () => {
+    setPreflightError(null);
+    setPreparing(true);
+    void createSnapshot()
+      .then((snapshot) => controller.current?.start({ snapshot, headers, view }))
+      .catch((error: unknown) => {
+        setPreflightError(error instanceof Error ? error.message : String(error));
+      })
+      .finally(() => setPreparing(false));
   };
   return (
     <>
       <button
         aria-label="Exportar Excel"
         className="excel-export-action"
-        disabled={state.status === "running"}
+        disabled={preparing || state.status === "running"}
         onClick={start}
         type="button"
       >
         <Download aria-hidden="true" size={16} />
         Exportar Excel
       </button>
-      {state.status === "running" ? <ExportProgressToast progress={state.progress} /> : null}
+      {preparing || state.status === "running" ? (
+        <ExportProgressToast progress={state.progress} />
+      ) : null}
       {showSuccess ? <ExportSuccessToast /> : null}
       {state.status === "failed" ? <p role="alert">Falha ao exportar: {state.error}</p> : null}
+      {preflightError !== null ? (
+        <p role="alert">Falha ao preparar exporta&ccedil;&atilde;o: {preflightError}</p>
+      ) : null}
     </>
   );
 }

package/templates/.agents/dashboard/modules/operations/src/react/export/export-layout.test.ts

@@ -2,6 +2,10 @@ import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 
 const operationsPage = readFileSync(new URL("../OperationsPage.tsx", import.meta.url), "utf8");
+const operationsNavigation = readFileSync(
+  new URL("../OperationsPageNavigation.tsx", import.meta.url),
+  "utf8",
+);
 const costMonitorPage = readFileSync(
   new URL("../../../../cost-monitor/src/react/CostMonitorPage.tsx", import.meta.url),
   "utf8",
@@ -20,9 +24,15 @@ describe("Excel export layout", () => {
     expect(action).toContain('aria-label="Exportar Excel"');
     expect(action).toContain("<Download");
     expect(action).toContain("Exportar Excel");
+    expect(action).toContain("ExportProgressToast");
+  });
+
+  it("uses the paginated board source rather than just visible Kanban rows", () => {
+    expect(operationsPage).toContain('pageSource={\n                        view === "work-kanban"');
+    expect(operationsPage).toContain("boardExportSource?.({");
   });
 
-  it("places the Operations action inside the tab nav, not global controls", () => {
+  it("keeps the Operations action outside the tab nav and fixed at the bar end", () => {
     const controls = operationsPage.slice(
       operationsPage.indexOf('<section className="dashboard-global-controls">'),
       operationsPage.indexOf(
@@ -38,10 +48,13 @@ describe("Excel export layout", () => {
       ),
     );
     expect(controls).not.toContain("<ExcelExportAction");
-    expect(toolbar.indexOf(").map((key) =>")).toBeLessThan(toolbar.indexOf("<ExcelExportAction"));
+    expect(toolbar).toContain("<OperationsViewTabs");
+    expect(operationsNavigation).toContain("views.map((key) =>");
+    expect(operationsNavigation).not.toContain("<ExcelExportAction");
+    expect(toolbar).toContain('<div className="operations-tab-export">');
   });
 
-  it("places the Cost Monitor action inside cost-tabs and keeps tab-like action styling", () => {
+  it("keeps Cost Monitor tabs semantic and fixes the export action at the bar end", () => {
     const tabs = costMonitorPage.slice(
       costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
       costMonitorPage.indexOf(
@@ -49,7 +62,10 @@ describe("Excel export layout", () => {
         costMonitorPage.indexOf('<nav aria-label="Visões de custo" className="cost-tabs">'),
       ),
     );
-    expect(tabs.indexOf("COST_VIEW_ORDER.map")).toBeLessThan(tabs.indexOf("<ExcelExportAction"));
+    expect(tabs).toContain("COST_VIEW_ORDER.map");
+    expect(tabs).not.toContain("<ExcelExportAction");
+    expect(costMonitorPage).toContain('<div className="cost-tabs-bar">');
+    expect(costMonitorPage).toContain('<div className="cost-tab-export">');
     expect(css).toContain(".excel-export-action");
     expect(css).toContain("display: inline-flex");
   });
@@ -63,5 +79,14 @@ describe("Excel export layout", () => {
       expect(tabCss).toContain("font-size: 0.82rem");
       expect(tabCss).toMatch(/padding(?:-inline)?:[^;]*10px/);
     }
+    expect(costMonitorCss).toContain("grid-template-columns: minmax(0, 1fr) auto");
+    expect(costMonitorCss).toContain("min-height: 44px");
+    expect(costMonitorCss).toContain("border-radius: 999px");
+    expect(costMonitorCss).toContain("font-size: 0.82rem");
+    expect(costMonitorCss).toContain("width: 14px");
+    expect(costMonitorPage).not.toContain("cost-coverage-note");
+    expect(costMonitorCss).not.toContain("cost-coverage-note");
+    expect(operationsCss).toContain(".operations-tab-export .excel-export-action");
+    expect(operationsCss).toContain("width: 14px");
   });
 });

package/templates/.agents/dashboard/modules/operations/src/react/macro-planning-dialog-content.css

@@ -0,0 +1,49 @@
+.operations-macro-document {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  gap: 12px;
+  padding: 13px 15px;
+  border: 1px solid rgba(148, 163, 184, 0.12);
+  border-radius: 14px;
+  color: #7890aa;
+  background: rgba(12, 20, 34, 0.52);
+}
+
+.operations-macro-document div {
+  display: grid;
+  min-width: 0;
+  gap: 4px;
+}
+
+.operations-macro-document span {
+  font-size: 0.63rem;
+  font-weight: 750;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.operations-macro-document code {
+  overflow: hidden;
+  color: #a4b8cf;
+  font-size: 0.69rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.operations-macro-empty {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  min-height: 92px;
+  border: 1px dashed rgba(var(--macro-accent-rgb), 0.22);
+  border-radius: 16px;
+  color: #8193aa;
+  background: rgba(var(--macro-accent-rgb), 0.025);
+}
+
+.operations-macro-empty p {
+  margin: 0;
+  font-size: 0.78rem;
+}

package/templates/.agents/dashboard/modules/operations/src/react/macro-planning-dialog.css

@@ -315,6 +315,99 @@
   border-top: 1px solid rgba(148, 163, 184, 0.14);
   border-bottom: 0;
 }
+.operations-prd-document-loading,
+.operations-prd-document-error {
+  display: grid;
+  gap: 22px;
+  border: 1px solid rgba(187, 167, 255, 0.2);
+  border-radius: 16px;
+  padding: 22px;
+  background: linear-gradient(135deg, rgba(187, 167, 255, 0.09), rgba(12, 20, 34, 0.28));
+}
+.operations-prd-document-loading-copy {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+}
+.operations-prd-document-loading-copy strong,
+.operations-prd-document-error strong {
+  color: #edf4ff;
+  font-size: 0.88rem;
+}
+.operations-prd-document-loading-copy p,
+.operations-prd-document-error p {
+  margin: 4px 0 0;
+  color: #8da0b8;
+  font-family: inherit;
+  font-size: 0.76rem;
+}
+.operations-prd-document-spinner {
+  flex: 0 0 auto;
+  color: #bba7ff;
+  animation: operations-document-spin 1s linear infinite;
+}
+.operations-prd-document-skeleton {
+  display: grid;
+  gap: 10px;
+}
+.operations-prd-document-skeleton i {
+  display: block;
+  height: 11px;
+  border-radius: 999px;
+  background: linear-gradient(
+    90deg,
+    rgba(148, 163, 184, 0.1),
+    rgba(187, 167, 255, 0.25),
+    rgba(148, 163, 184, 0.1)
+  );
+  background-size: 220% 100%;
+  animation: operations-document-shimmer 1.5s ease-in-out infinite;
+}
+.operations-prd-document-skeleton i:nth-child(2) {
+  width: 88%;
+  animation-delay: 90ms;
+}
+.operations-prd-document-skeleton i:nth-child(3) {
+  width: 72%;
+  animation-delay: 180ms;
+}
+.operations-prd-document-skeleton i:nth-child(4) {
+  width: 82%;
+  animation-delay: 270ms;
+}
+.operations-prd-document-error {
+  border-color: rgba(251, 146, 60, 0.36);
+}
+.operations-prd-document-error button {
+  display: inline-flex;
+  width: fit-content;
+  align-items: center;
+  gap: 7px;
+  border: 1px solid rgba(187, 167, 255, 0.36);
+  border-radius: 9px;
+  padding: 8px 11px;
+  color: #e8e5ff;
+  background: rgba(187, 167, 255, 0.1);
+  cursor: pointer;
+  font-size: 0.75rem;
+  font-weight: 750;
+}
+@keyframes operations-document-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@keyframes operations-document-shimmer {
+  to {
+    background-position: -220% 0;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .operations-prd-document-spinner,
+  .operations-prd-document-skeleton i {
+    animation: none;
+  }
+}
 
 .operations-macro-dialog-scroll {
   display: grid;
@@ -700,53 +793,3 @@
   font-weight: 750;
   white-space: nowrap;
 }
-
-.operations-macro-document {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  gap: 12px;
-  padding: 13px 15px;
-  border: 1px solid rgba(148, 163, 184, 0.12);
-  border-radius: 14px;
-  color: #7890aa;
-  background: rgba(12, 20, 34, 0.52);
-}
-
-.operations-macro-document div {
-  display: grid;
-  min-width: 0;
-  gap: 4px;
-}
-
-.operations-macro-document span {
-  font-size: 0.63rem;
-  font-weight: 750;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
-.operations-macro-document code {
-  overflow: hidden;
-  color: #a4b8cf;
-  font-size: 0.69rem;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.operations-macro-empty {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 10px;
-  min-height: 92px;
-  border: 1px dashed rgba(var(--macro-accent-rgb), 0.22);
-  border-radius: 16px;
-  color: #8193aa;
-  background: rgba(var(--macro-accent-rgb), 0.025);
-}
-
-.operations-macro-empty p {
-  margin: 0;
-  font-size: 0.78rem;
-}

package/templates/.agents/dashboard/modules/operations/src/react/manual-work-priority.test.ts

@@ -0,0 +1,82 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { mergeManualWorkOrder, openWorkCardLabel, sortWorkItems } from "./UnifiedWorkBoard.js";
+
+const board = readFileSync(new URL("UnifiedWorkBoard.tsx", import.meta.url), "utf8");
+const app = readFileSync(new URL("../../../../apps/frontend/src/App.tsx", import.meta.url), "utf8");
+const priorityHandler = app.slice(
+  app.indexOf("onPriorityChange={async"),
+  app.indexOf("onPeriodChange="),
+);
+const styles = readFileSync(new URL("unified-work-board.css", import.meta.url), "utf8");
+const requirements = readFileSync(
+  new URL("../../../../../requirements/kanban-dashboard.md", import.meta.url),
+  "utf8",
+);
+
+describe("manual work priority interactions", () => {
+  it("updates locally without waiting for a full projection refresh and restores the previous order on failure", () => {
+    expect(priorityHandler).toContain("await api.saveWorkPriority(itemIds)");
+    expect(priorityHandler).toContain(
+      "setError(cause instanceof Error ? cause.message : String(cause))",
+    );
+    expect(priorityHandler).not.toContain("await refresh();");
+    expect(board).toContain("setOptimisticOrder(nextOrder)");
+    expect(board).toContain("setOptimisticOrder(previous)");
+  });
+
+  it("supports drag/drop and separate keyboard controls without nesting controls inside a button", () => {
+    expect(board).toContain("draggable");
+    expect(board).toContain("onDragStart");
+    expect(board).toMatch(/onDrop=\{\s*stage === "ready"\s*\?\s*\(event\)/);
+    expect(board).toContain('locale === "pt-BR" ? "Mover acima" : "Move up"');
+    expect(board).toContain('locale === "pt-BR" ? "Mover abaixo" : "Move down"');
+    expect(board).toContain('className="operations-work-card-open"');
+    expect(board).toContain("<article");
+    expect(board).not.toContain('role="button"');
+  });
+
+  it("merges a column reorder into the global queue without replacing other ranks", () => {
+    const work = (id: string) => ({ kind: "task", row: { id } }) as never;
+    expect(
+      mergeManualWorkOrder(
+        [work("PRD"), work("A"), work("SPEC"), work("B")],
+        [work("A"), work("B")],
+        [work("B"), work("A")],
+      ),
+    ).toEqual(["PRD", "B", "SPEC", "A"]);
+  });
+
+  it("renders the queued order immediately from the accepted priority contract", () => {
+    const work = (id: string) => ({ kind: "task", row: { id, updated_at: "" } }) as never;
+    expect(
+      sortWorkItems([work("A"), work("B"), work("C")], ["C", "A", "B"]).map((item) => item.row.id),
+    ).toEqual(["C", "A", "B"]);
+  });
+
+  it("localizes the accessible card action label", () => {
+    expect(openWorkCardLabel("pt-BR", "Fila")).toBe("Abrir Fila");
+    expect(openWorkCardLabel("en-US", "Queue")).toBe("Open Queue");
+  });
+
+  it("styles only the actual interactive surfaces as clickable and retains the historical AC sequence", () => {
+    expect(styles).toContain(".operations-work-card {\n  cursor: default;");
+    expect(styles).toContain(".operations-work-card-open {\n  display: flex;");
+    expect(styles).toContain(".operations-work-card-open:hover > strong");
+    expect(styles).toContain(".operations-work-reorder button {");
+    expect(styles).toContain(".operations-work-order,");
+    expect(styles).toContain(
+      ".operations-work-reorder {\n  position: absolute;\n  top: 10px;\n  right: 10px;",
+    );
+    expect(board).toContain(
+      "<span className={`operations-work-kind is-${item.kind}`}>{kindLabel}</span>",
+    );
+    expect(board).toContain('<span className="operations-work-order">#{order}</span>');
+    expect(requirements.indexOf("`AC-DASH-001-12`:")).toBeLessThan(
+      requirements.indexOf("`AC-DASH-001-13`:"),
+    );
+    expect(requirements.indexOf("`AC-DASH-001-13`:")).toBeLessThan(
+      requirements.indexOf("`AC-DASH-001-14`: o Kanban"),
+    );
+  });
+});