@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/modules/operations/src/react/UnifiedWorkBoard.tsx

@@ -14,6 +14,7 @@ import { formatRoundedDuration } from "./format-rounded-duration.js";
 import { MacroPlanningDialog } from "./MacroPlanningDialog.js";
 import { type OperationsLocale, riskLabel } from "./status-labels.js";
 import { taskTotals } from "./TaskBoard.js";
+import { TaskDetailsDialog } from "./TaskDetailsDialog.js";
 import { taskOrigin } from "./task-origin.js";
 import { useCurrentTime } from "./use-current-time.js";
 import { useInfiniteColumn } from "./use-infinite-column.js";
@@ -36,23 +37,44 @@ type WorkItem =
   | { kind: "prd" | "spec"; row: MacroProjection };
 
 export function UnifiedWorkBoard({
+  allPrds,
   allSpecs,
   allTasks,
+  boardTotals,
+  boardKindTotals,
+  boardStates,
   changes,
   locale,
   onOpenDocument,
   onOpenTask,
+  onPriorityChange,
+  onLoadMore,
+  onTypeChange,
   prds,
   runs,
   specs,
   tasks,
 }: {
+  allPrds: readonly MacroProjection[];
   allSpecs: readonly MacroProjection[];
   allTasks: readonly DashboardTaskProjection[];
+  boardTotals?: Partial<Record<WorkStage, number>> | undefined;
+  boardKindTotals?:
+    | Partial<
+        Record<
+          WorkStage,
+          { all: number; task: number; "standalone-task": number; prd: number; spec: number }
+        >
+      >
+    | undefined;
+  boardStates?: Partial<Record<WorkStage, { loading: boolean; error: string | null }>> | undefined;
   changes: readonly ChangeProjection[];
   locale: OperationsLocale;
   onOpenDocument: (kind: "prd" | "spec", id: string) => void;
   onOpenTask: (taskId: string) => Promise<boolean>;
+  onPriorityChange: (itemIds: readonly string[]) => Promise<void>;
+  onLoadMore?: ((stage: WorkStage) => void) | undefined;
+  onTypeChange?: ((value: WorkTypeFilter) => void) | undefined;
   prds: readonly MacroProjection[];
   runs: readonly RunProjection[];
   specs: readonly MacroProjection[];
@@ -62,18 +84,29 @@ export function UnifiedWorkBoard({
   const [typeFilter, setTypeFilter] = useState<WorkTypeFilter>("all");
   const [selectedStage, setSelectedStage] = useState<WorkStage | null>(null);
   const [selectedMacro, setSelectedMacro] = useState<MacroProjection | null>(null);
+  const [selectedTask, setSelectedTask] = useState<DashboardTaskProjection | null>(null);
   const [query, setQuery] = useState("");
-  const totalsByTask = useMemo(() => taskTotals(runs, tasks), [runs, tasks]);
-  const items = useMemo(
+  const [draggedId, setDraggedId] = useState<string | null>(null);
+  const [optimisticOrder, setOptimisticOrder] = useState<readonly string[] | null>(null);
+  // Card telemetry comes from the compact per-Task projection.  Do not scan the
+  // complete Run collection when a card opens; absent compact telemetry remains
+  // unavailable instead of being reconstructed from a partial page of Runs.
+  const totalsByTask = useMemo(() => taskTotals([], tasks), [tasks]);
+  const allItems = useMemo(
     () =>
       sortWorkItems(
         [
-          ...prds.map((row): WorkItem => ({ kind: "prd", row })),
-          ...specs.map((row): WorkItem => ({ kind: "spec", row })),
-          ...tasks.map((row): WorkItem => ({ kind: "task", row })),
-        ].filter((item) => isWorkItemVisible(item, typeFilter)),
+          ...allPrds.map((row): WorkItem => ({ kind: "prd", row })),
+          ...allSpecs.map((row): WorkItem => ({ kind: "spec", row })),
+          ...allTasks.map((row): WorkItem => ({ kind: "task", row })),
+        ],
+        optimisticOrder,
       ),
-    [prds, specs, tasks, typeFilter],
+    [allPrds, allSpecs, allTasks, optimisticOrder],
+  );
+  const items = useMemo(
+    () => allItems.filter((item) => isWorkItemVisible(item, typeFilter)),
+    [allItems, typeFilter],
   );
   const progressByMacro = useMemo(
     () =>
@@ -88,12 +121,19 @@ export function UnifiedWorkBoard({
       : items.filter((item) => itemStage(item, allTasks) === selectedStage);
   const openItem = (item: WorkItem) => {
     setSelectedStage(null);
-    if (item.kind === "task") void onOpenTask(item.row.id);
+    if (item.kind === "task") setSelectedTask(item.row);
     else setSelectedMacro(item.row);
   };
   return (
     <section className="operations-unified-work">
-      <WorkTypeFilters locale={locale} onChange={setTypeFilter} value={typeFilter} />
+      <WorkTypeFilters
+        locale={locale}
+        onChange={(value) => {
+          setTypeFilter(value);
+          onTypeChange?.(value);
+        }}
+        value={typeFilter}
+      />
       <section
         aria-label={locale === "pt-BR" ? "Kanban de trabalho" : "Work Kanban"}
         className="operations-board operations-work-board"
@@ -103,6 +143,7 @@ export function UnifiedWorkBoard({
           return (
             <WorkColumn
               changes={changes}
+              globalItems={allItems}
               items={rows}
               key={stage}
               locale={locale}
@@ -111,9 +152,33 @@ export function UnifiedWorkBoard({
                 setQuery("");
                 setSelectedStage(stage);
               }}
+              onLoadMore={onLoadMore === undefined ? undefined : () => onLoadMore(stage)}
               onOpenItem={openItem}
+              onPriorityChange={async (nextOrder) => {
+                const previous = optimisticOrder;
+                setOptimisticOrder(nextOrder);
+                try {
+                  await onPriorityChange(nextOrder);
+                } catch {
+                  setOptimisticOrder(previous);
+                }
+              }}
+              onDragEnd={() => setDraggedId(null)}
+              onDragStart={setDraggedId}
+              draggedId={draggedId}
               progressByMacro={progressByMacro}
               stage={stage}
+              totalItems={
+                typeFilter === "all"
+                  ? (boardKindTotals?.[stage]?.all ?? boardTotals?.[stage] ?? rows.length)
+                  : typeFilter === "task" ||
+                      typeFilter === "standalone-task" ||
+                      typeFilter === "prd" ||
+                      typeFilter === "spec"
+                    ? (boardKindTotals?.[stage]?.[typeFilter] ?? rows.length)
+                    : rows.length
+              }
+              state={boardStates?.[stage]}
               totalsByTask={totalsByTask}
             />
           );
@@ -146,10 +211,31 @@ export function UnifiedWorkBoard({
           tasks={allTasks}
         />
       ) : null}
+      {selectedTask ? (
+        <TaskDetailsDialog
+          detail={{ task: selectedTask, body: "", artifact_path: selectedTask.artifact_path }}
+          locale={locale}
+          onClose={() => setSelectedTask(null)}
+          onOpenTrace={(taskId) => {
+            setSelectedTask(null);
+            void onOpenTask(taskId);
+          }}
+          operations={{ decisions: [], runs }}
+          summary
+          summaryRunCount={exactTaskRunCount(selectedTask)}
+        />
+      ) : null}
     </section>
   );
 }
 
+function exactTaskRunCount(task: DashboardTaskProjection): number | null {
+  const runCount = (task as DashboardTaskProjection & { run_count?: unknown }).run_count;
+  return typeof runCount === "number" && Number.isInteger(runCount) && runCount >= 0
+    ? runCount
+    : null;
+}
+
 export function WorkTypeFilters({
   locale,
   onChange,
@@ -166,7 +252,7 @@ export function WorkTypeFilters({
           all: "Tudo",
           prd: "PRDs",
           spec: "SPECs",
-          "standalone-task": "Tarefas Avulsas",
+          "standalone-task": "Tarefa Avulsa",
         }
       : {
           task: "Tasks",
@@ -175,7 +261,7 @@ export function WorkTypeFilters({
           spec: "SPECs",
           "standalone-task": "Standalone Tasks",
         };
-  const filterOrder: readonly WorkTypeFilter[] = ["all", "task", "prd", "spec"];
+  const filterOrder: readonly WorkTypeFilter[] = ["all", "task", "standalone-task", "prd", "spec"];
   return (
     <nav
       aria-label={locale === "pt-BR" ? "Filtrar tipo de trabalho" : "Filter work type"}
@@ -197,26 +283,46 @@ export function WorkTypeFilters({
 
 function WorkColumn({
   changes,
+  globalItems,
   items,
+  totalItems,
+  state,
   locale,
   nowMs,
   onOpenColumn,
+  onLoadMore,
   onOpenItem,
+  onPriorityChange,
+  onDragEnd,
+  onDragStart,
+  draggedId,
   progressByMacro,
   stage,
   totalsByTask,
 }: {
   changes: readonly ChangeProjection[];
+  globalItems: readonly WorkItem[];
   items: readonly WorkItem[];
+  totalItems: number;
+  state: { loading: boolean; error: string | null } | undefined;
   locale: OperationsLocale;
   nowMs: number;
   onOpenColumn: () => void;
+  onLoadMore?: (() => void) | undefined;
   onOpenItem: (item: WorkItem) => void;
+  onPriorityChange: (itemIds: readonly string[]) => Promise<void>;
+  onDragEnd: () => void;
+  onDragStart: (id: string) => void;
+  draggedId: string | null;
   progressByMacro: ReadonlyMap<string, MacroWorkProgress>;
   stage: WorkStage;
   totalsByTask: ReturnType<typeof taskTotals>;
 }) {
-  const { hasMore, sentinelRef, visibleCount } = useInfiniteColumn(items.length);
+  const { hasMore, sentinelRef, visibleCount } = useInfiniteColumn(
+    items.length,
+    totalItems,
+    onLoadMore,
+  );
   return (
     <article className={`operations-column is-${stage}`}>
       <header>
@@ -224,16 +330,16 @@ function WorkColumn({
           {workStageLabel(stage, locale)}
         </button>
         <button
-          aria-label={`${items.length} — ${workStageLabel(stage, locale)}`}
+          aria-label={`${totalItems} — ${workStageLabel(stage, locale)}`}
           className="operations-column-count"
           onClick={onOpenColumn}
           type="button"
         >
-          {items.length}
+          {totalItems}
         </button>
       </header>
       <div className="operations-column-body">
-        {items.slice(0, visibleCount).map((item) => (
+        {items.slice(0, visibleCount).map((item, index) => (
           <WorkCard
             changes={changes}
             item={item}
@@ -241,17 +347,52 @@ function WorkColumn({
             locale={locale}
             nowMs={nowMs}
             onOpen={() => onOpenItem(item)}
+            onMove={(direction) => {
+              const next = index + direction;
+              if (next < 0 || next >= items.length) return;
+              const reordered = [...items];
+              [reordered[index], reordered[next]] = [reordered[next]!, reordered[index]!];
+              void onPriorityChange(mergeManualWorkOrder(globalItems, items, reordered));
+            }}
+            onDrop={() => {
+              const from = items.findIndex((candidate) => candidate.row.id === draggedId);
+              if (from < 0 || from === index) return;
+              const reordered = [...items];
+              const [moved] = reordered.splice(from, 1);
+              if (moved === undefined) return;
+              reordered.splice(index, 0, moved);
+              void onPriorityChange(mergeManualWorkOrder(globalItems, items, reordered));
+            }}
+            onDragEnd={onDragEnd}
+            onDragStart={() => onDragStart(item.row.id)}
+            order={index + 1}
             progress={progressByMacro.get(item.row.id)}
             stage={stage}
             totalsByTask={totalsByTask}
           />
         ))}
-        {items.length === 0 ? (
+        {items.length === 0 && !state?.loading ? (
           <p className="operations-empty">{locale === "pt-BR" ? "Sem itens" : "No items"}</p>
         ) : null}
         {hasMore ? (
-          <div className="operations-infinite-sentinel" ref={sentinelRef}>
-            {visibleCount} de {items.length} · carregando mais…
+          <div
+            aria-live="polite"
+            className="operations-infinite-sentinel"
+            ref={sentinelRef}
+            role={state?.error ? "alert" : "status"}
+          >
+            {state?.error ? (
+              <>
+                <span>{state.error}</span>
+                <button onClick={onLoadMore} type="button">
+                  Tentar novamente
+                </button>
+              </>
+            ) : state?.loading ? (
+              "Carregando mais…"
+            ) : (
+              `${visibleCount} de ${totalItems} · carregando mais…`
+            )}
           </div>
         ) : null}
       </div>
@@ -265,6 +406,11 @@ function WorkCard({
   locale,
   nowMs,
   onOpen,
+  onMove,
+  onDrop,
+  onDragEnd,
+  onDragStart,
+  order,
   progress,
   stage,
   totalsByTask,
@@ -274,6 +420,11 @@ function WorkCard({
   locale: OperationsLocale;
   nowMs: number;
   onOpen: () => void;
+  onMove: (direction: -1 | 1) => void;
+  onDrop: () => void;
+  onDragEnd: () => void;
+  onDragStart: () => void;
+  order: number;
   progress: MacroWorkProgress | undefined;
   stage: WorkStage;
   totalsByTask: ReturnType<typeof taskTotals>;
@@ -288,19 +439,64 @@ function WorkCard({
     ? [macro.duration_ms, macro.usage.total.tokens.total, macro.usage.total.cost.brl]
     : [totals?.durationMs ?? null, totals?.tokens ?? null, totals?.costBrl ?? null];
   return (
-    <button
+    <article
       className={`operations-task-card operations-work-card is-kind-${origin}`}
-      onClick={onOpen}
-      type="button"
+      draggable={stage === "ready"}
+      onDragEnd={stage === "ready" ? onDragEnd : undefined}
+      onDragOver={stage === "ready" ? (event) => event.preventDefault() : undefined}
+      onDragStart={stage === "ready" ? onDragStart : undefined}
+      onDrop={
+        stage === "ready"
+          ? (event) => {
+              event.preventDefault();
+              onDrop();
+            }
+          : undefined
+      }
     >
-      <span className={`operations-work-kind is-${item.kind}`}>{kindLabel}</span>
-      <span className={`operations-work-status is-${stage}`}>
-        {workStageBadgeLabel(stage, locale)}
-      </span>
-      {task ? (
-        <span className={`operations-risk is-${task.risk}`}>{riskLabel(task.risk, locale)}</span>
+      <button
+        aria-label={openWorkCardLabel(locale, item.row.title)}
+        className="operations-work-card-open"
+        onClick={onOpen}
+        type="button"
+      >
+        {stage === "ready" ? (
+          <span className="operations-work-card-first-line">
+            <span className="operations-work-order">#{order}</span>
+          </span>
+        ) : null}
+        <span className={`operations-work-kind is-${item.kind}`}>{kindLabel}</span>
+        {order === 1 && stage === "ready" ? (
+          <span className="operations-work-next">Próximo</span>
+        ) : null}
+        {stage !== "ready" ? (
+          <span className={`operations-work-status is-${stage}`}>
+            {workStageBadgeLabel(stage, locale)}
+          </span>
+        ) : null}
+        {task ? (
+          <span className={`operations-risk is-${task.risk}`}>{riskLabel(task.risk, locale)}</span>
+        ) : null}
+        <strong title={item.row.title}>{item.row.title}</strong>
+      </button>
+      {stage === "ready" ? (
+        <div className="operations-work-reorder">
+          <button
+            aria-label={locale === "pt-BR" ? "Mover acima" : "Move up"}
+            onClick={() => onMove(-1)}
+            type="button"
+          >
+            ↑
+          </button>
+          <button
+            aria-label={locale === "pt-BR" ? "Mover abaixo" : "Move down"}
+            onClick={() => onMove(1)}
+            type="button"
+          >
+            ↓
+          </button>
+        </div>
       ) : null}
-      <strong title={item.row.title}>{item.row.title}</strong>
       <small title={item.row.id}>{item.row.id}</small>
       {item.row.created_at ? (
         <small className="operations-card-created">
@@ -343,7 +539,25 @@ function WorkCard({
           </div>
         ))}
       </dl>
-    </button>
+    </article>
+  );
+}
+
+export function openWorkCardLabel(locale: OperationsLocale, title: string): string {
+  return locale === "pt-BR" ? `Abrir ${title}` : `Open ${title}`;
+}
+
+/** Replaces only visible-column slots, preserving the global order of all other work. */
+export function mergeManualWorkOrder(
+  globalItems: readonly WorkItem[],
+  previousColumn: readonly WorkItem[],
+  reorderedColumn: readonly WorkItem[],
+): string[] {
+  const columnIds = new Set(previousColumn.map((item) => item.row.id));
+  const reorderedIds = reorderedColumn.map((item) => item.row.id);
+  let cursor = 0;
+  return globalItems.map((item) =>
+    columnIds.has(item.row.id) ? (reorderedIds[cursor++] ?? item.row.id) : item.row.id,
   );
 }
 
@@ -448,18 +662,33 @@ function itemStage(item: WorkItem, tasks: readonly DashboardTaskProjection[]): W
   return item.kind === "task" ? taskWorkStage(item.row) : macroWorkStage(item.row, tasks);
 }
 
-function sortWorkItems(items: WorkItem[]): WorkItem[] {
-  const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 } as const;
+export function sortWorkItems(
+  items: WorkItem[],
+  optimisticOrder: readonly string[] | null = null,
+): WorkItem[] {
+  const optimisticRanks =
+    optimisticOrder === null ? null : new Map(optimisticOrder.map((id, index) => [id, index]));
   return items.sort(
     (left, right) =>
-      workItemTimestamp(right).localeCompare(workItemTimestamp(left)) ||
-      String(itemStage(left, [])).localeCompare(String(itemStage(right, []))) ||
-      (left.kind === "task" ? priorityOrder[left.row.priority] : 4) -
-        (right.kind === "task" ? priorityOrder[right.row.priority] : 4) ||
-      right.row.id.localeCompare(left.row.id),
+      compareManualOrder(
+        optimisticRanks?.get(left.row.id) ?? left.row.manual_order,
+        optimisticRanks?.get(right.row.id) ?? right.row.manual_order,
+      ) ||
+      workItemTimestamp(left).localeCompare(workItemTimestamp(right)) ||
+      left.row.id.localeCompare(right.row.id),
   );
 }
 
+function compareManualOrder(
+  left: number | null | undefined,
+  right: number | null | undefined,
+): number {
+  if (left != null && right != null) return left - right;
+  if (left != null) return -1;
+  if (right != null) return 1;
+  return 0;
+}
+
 function workItemTimestamp(item: WorkItem): string {
   return item.kind === "task"
     ? item.row.updated_at

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

@@ -1,9 +1,55 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
-import type { DashboardTaskProjection, RunProjection } from "../contracts.js";
-import { buildWorkListRows } from "./UnifiedWorkList.js";
+import type { DashboardTaskProjection, MacroProjection, RunProjection } from "../contracts.js";
+import { buildWorkListRows, formatWorkListDuration } from "./UnifiedWorkList.js";
 
 describe("buildWorkListRows", () => {
-  it("aggregates run, sub-run, execution, duration, token and cost indicators for a task", () => {
+  it("labels only active missing time as in progress and preserves temporal absence elsewhere", () => {
+    expect(formatWorkListDuration(null, "executing", "pt-BR")).toBe("Em andamento");
+    expect(formatWorkListDuration(null, "blocked", "pt-BR")).toBe("Sem atribuição temporal");
+    expect(formatWorkListDuration(0, "cancelled", "pt-BR")).toBe("0 seg");
+  });
+
+  it("keeps the operational list to its eight standard columns", () => {
+    const source = readFileSync(
+      fileURLToPath(new URL("./UnifiedWorkList.tsx", import.meta.url)),
+      "utf8",
+    );
+    const keys = [...source.matchAll(/key: "([^"]+)"/g)].map((match) => match[1]);
+    expect(keys.slice(0, 8)).toEqual([
+      "item",
+      "status",
+      "type",
+      "risk",
+      "progress",
+      "time",
+      "tokens",
+      "cost",
+    ]);
+    expect(source).toContain('label: "Item"');
+    expect(source).toContain('label: "Status"');
+    expect(source).toContain('label: locale === "pt-BR" ? "Tipo" : "Type"');
+    expect(source).toContain('label: locale === "pt-BR" ? "Risco" : "Risk"');
+    expect(source).toContain('label: locale === "pt-BR" ? "Progresso" : "Progress"');
+    expect(source).toContain('label: locale === "pt-BR" ? "Tempo" : "Time"');
+    expect(source).toContain('label: "Tokens"');
+    expect(source).toContain('label: locale === "pt-BR" ? "Custo" : "Cost"');
+    expect(keys).not.toEqual(
+      expect.arrayContaining(["runs", "lifecycleElapsed", "executions", "tasks", "duration"]),
+    );
+    expect(source).not.toContain("taskOriginLabel");
+  });
+
+  it("propagates the selected type so the server can fetch that canonical collection", () => {
+    const source = readFileSync(
+      fileURLToPath(new URL("./UnifiedWorkList.tsx", import.meta.url)),
+      "utf8",
+    );
+    expect(source).toContain("onTypeChange?.(kind)");
+  });
+
+  it("uses paginated Runs only when task telemetry is absent", () => {
     const task = {
       id: "TASK-1",
       title: "List operational work",
@@ -18,6 +64,7 @@ describe("buildWorkListRows", () => {
       task_id: task.id,
       execution_id: "EXEC-1",
       duration_ms: 1_000,
+      source_duration_ms: 1_000,
       phase: "execution",
       parent_run_id: null,
       usage: { total: { tokens: { total: 120 }, cost: { brl: 0.25 } } },
@@ -29,15 +76,18 @@ describe("buildWorkListRows", () => {
       items: [{ kind: "task", row: task }],
       runs: [
         { ...baseRun, id: "RUN-1", run_kind: "run" },
-        { ...baseRun, id: "RUN-2", run_kind: "subrun", parent_run_id: "RUN-1", duration_ms: 500 },
+        {
+          ...baseRun,
+          id: "RUN-2",
+          run_kind: "subrun",
+          parent_run_id: "RUN-1",
+          duration_ms: 500,
+          source_duration_ms: 500,
+        },
       ],
     });
 
     expect(rows[0]).toMatchObject({
-      runCount: 1,
-      subrunCount: 1,
-      executionCount: 1,
-      taskCount: 1,
       durationMs: 1_000,
       tokens: 240,
       costBrl: 0.5,
@@ -45,4 +95,117 @@ describe("buildWorkListRows", () => {
       stage: "executing",
     });
   });
+
+  it("prefers consolidated task telemetry over incomplete paginated Runs", () => {
+    const task = {
+      id: "TASK-FAST-SNAPSHOT",
+      title: "Telemetry from task projection",
+      status: "executing",
+      progress: 50,
+      spec_id: null,
+      telemetry: { duration_ms: 1_500, tokens: 9_000, cost_brl: 7.5 },
+    } as DashboardTaskProjection;
+
+    const [row] = buildWorkListRows({
+      allSpecs: [],
+      allTasks: [task],
+      changes: [],
+      items: [{ kind: "task", row: task }],
+      runs: [
+        {
+          id: "RUN-PAGE",
+          task_id: "TASK-FAST-SNAPSHOT",
+          run_kind: "run",
+          phase: "execution",
+          parent_run_id: null,
+          duration_ms: 10,
+          source_duration_ms: 10,
+          usage: { total: { tokens: { total: 1 }, cost: { brl: 0.01 } } },
+        } as RunProjection,
+      ],
+    });
+
+    expect(row).toMatchObject({ durationMs: 1_500, tokens: 9_000, costBrl: 7.5 });
+  });
+
+  it("renders a known zero only for tasks with an explicit no-activity lifecycle state", () => {
+    const noActivity = {
+      id: "TASK-READY-NO-RUNS",
+      title: "Prepared without execution",
+      status: "planned",
+      risk: "lite",
+      progress: 0,
+      spec_id: null,
+      execution_started: false,
+      execution_count: 0,
+    } as DashboardTaskProjection;
+    const unavailable = {
+      ...noActivity,
+      id: "TASK-PARTIAL-PAGE",
+      execution_started: true,
+      execution_count: 1,
+    } as DashboardTaskProjection;
+    const cancelledNoActivity = {
+      ...noActivity,
+      id: "TASK-CANCELLED-NO-RUNS",
+      status: "cancelled",
+    } as unknown as DashboardTaskProjection;
+    delete (cancelledNoActivity as { execution_count?: number }).execution_count;
+    const measured = {
+      ...noActivity,
+      id: "TASK-MEASURED",
+      execution_started: true,
+      execution_count: 1,
+      telemetry: { duration_ms: 60_000, tokens: 10, cost_brl: 1 },
+    } as DashboardTaskProjection;
+
+    const rows = buildWorkListRows({
+      allSpecs: [],
+      allTasks: [noActivity, unavailable, cancelledNoActivity, measured],
+      changes: [],
+      items: [
+        { kind: "task", row: noActivity },
+        { kind: "task", row: unavailable },
+        { kind: "task", row: cancelledNoActivity },
+        { kind: "task", row: measured },
+      ],
+      runs: [],
+    });
+
+    expect(rows.map((row) => row.durationMs)).toEqual([0, null, 0, 60_000]);
+    expect(rows.reduce((total, row) => total + (row.durationMs ?? 0), 0)).toBe(60_000);
+  });
+
+  it("renders a known zero for a macro with no materialized children or Runs", () => {
+    const emptyMacro = {
+      id: "SPEC-EMPTY",
+      title: "Empty specification",
+      kind: "spec",
+      lifecycle_status: "draft",
+      work_status: "planning",
+      created_at: null,
+      parent_id: null,
+      artifact_path: ".agents/records/specs/SPEC-EMPTY.md",
+      execution_ids: [],
+      task_ids: [],
+      planned_tasks: [],
+      run_ids: [],
+      task_count: 0,
+      execution_count: 0,
+      run_count: 0,
+      duration_ms: null,
+      quality: { task_completion_rate: 0 },
+      usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+    } as unknown as MacroProjection;
+
+    const [row] = buildWorkListRows({
+      allSpecs: [emptyMacro],
+      allTasks: [],
+      changes: [],
+      items: [{ kind: "spec", row: emptyMacro }],
+      runs: [],
+    });
+
+    expect(row?.durationMs).toBe(0);
+  });
 });