@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -8,10 +8,8 @@ import type {
 } from "../contracts.js";
 import { formatRoundedDuration } from "./format-rounded-duration.js";
 import { MacroPlanningDialog } from "./MacroPlanningDialog.js";
-import { formatOperationDuration } from "./operation-duration.js";
+import { formatDisplayedDuration, operationalDurationMs } from "./operation-duration.js";
 import { type OperationsLocale, riskLabel } from "./status-labels.js";
-import { taskTotals } from "./TaskBoard.js";
-import { taskOrigin, taskOriginLabel } from "./task-origin.js";
 import { WorkTypeFilters } from "./UnifiedWorkBoard.js";
 import {
   isWorkItemVisible,
@@ -31,13 +29,8 @@ type WorkItem =
 interface WorkListRow {
   item: WorkItem;
   stage: WorkStage;
-  originLabel: string;
   risk: string | null;
   progress: string;
-  runCount: number;
-  subrunCount: number;
-  executionCount: number;
-  taskCount: number;
   durationMs: number | null;
   tokens: number | null;
   costBrl: number | null;
@@ -54,6 +47,7 @@ export function UnifiedWorkList({
   runs,
   specs,
   tasks,
+  onTypeChange,
 }: {
   allSpecs: readonly MacroProjection[];
   allTasks: readonly DashboardTaskProjection[];
@@ -65,6 +59,7 @@ export function UnifiedWorkList({
   runs: readonly RunProjection[];
   specs: readonly MacroProjection[];
   tasks: readonly DashboardTaskProjection[];
+  onTypeChange?: ((kind: WorkTypeFilter) => void) | undefined;
 }) {
   const [typeFilter, setTypeFilter] = useState<WorkTypeFilter>("all");
   const [selectedMacro, setSelectedMacro] = useState<MacroProjection | null>(null);
@@ -86,16 +81,22 @@ export function UnifiedWorkList({
 
   return (
     <section className="operations-unified-work operations-work-list">
-      <WorkTypeFilters locale={locale} onChange={setTypeFilter} value={typeFilter} />
+      <WorkTypeFilters
+        locale={locale}
+        onChange={(kind) => {
+          setTypeFilter(kind);
+          onTypeChange?.(kind);
+        }}
+        value={typeFilter}
+      />
       <div className="operations-work-list-table">
         <DataTable
           columns={[
             {
               key: "item",
-              label: locale === "pt-BR" ? "Item de trabalho" : "Work item",
-              render: ({ item, originLabel }) => (
+              label: "Item",
+              render: ({ item }) => (
                 <span className="operations-work-list-identity">
-                  <span className={`operations-work-kind is-${item.kind}`}>{originLabel}</span>
                   <strong>{item.row.title}</strong>
                   <small>{item.row.id}</small>
                 </span>
@@ -112,6 +113,12 @@ export function UnifiedWorkList({
               ),
               sortValue: ({ stage }) => stage,
             },
+            {
+              key: "type",
+              label: locale === "pt-BR" ? "Tipo" : "Type",
+              render: ({ item }) => workItemTypeLabel(item.kind, locale),
+              sortValue: ({ item }) => item.kind,
+            },
             {
               key: "risk",
               label: locale === "pt-BR" ? "Risco" : "Risk",
@@ -131,48 +138,9 @@ export function UnifiedWorkList({
                 item.kind === "task" ? item.row.progress : item.row.quality.task_completion_rate,
             },
             {
-              key: "runs",
-              label: locale === "pt-BR" ? "Invocações do orquestrador" : "Orchestrator invocations",
-              description:
-                locale === "pt-BR"
-                  ? "Chamadas do agente orquestrador relacionadas ao item."
-                  : "Orchestrator agent calls related to the item.",
-              render: ({ runCount }) => runCount,
-              sortValue: ({ runCount }) => runCount,
-              align: "right",
-            },
-            {
-              key: "subruns",
-              label: locale === "pt-BR" ? "Invocações delegadas" : "Delegated invocations",
-              description:
-                locale === "pt-BR"
-                  ? "Chamadas de subagentes relacionadas ao item."
-                  : "Subagent calls related to the item.",
-              render: ({ subrunCount }) => subrunCount,
-              sortValue: ({ subrunCount }) => subrunCount,
-              align: "right",
-            },
-            {
-              key: "executions",
-              label: locale === "pt-BR" ? "Execuções" : "Executions",
-              render: ({ executionCount }) => executionCount,
-              sortValue: ({ executionCount }) => executionCount,
-              align: "right",
-            },
-            {
-              key: "tasks",
-              label: locale === "pt-BR" ? "Tarefas" : "Tasks",
-              render: ({ taskCount }) => taskCount,
-              sortValue: ({ taskCount }) => taskCount,
-              align: "right",
-            },
-            {
-              key: "duration",
+              key: "time",
               label: locale === "pt-BR" ? "Tempo" : "Time",
-              render: ({ durationMs }) =>
-                durationMs === null
-                  ? formatOperationDuration(null, locale)
-                  : formatRoundedDuration(durationMs),
+              render: ({ durationMs, stage }) => formatWorkListDuration(durationMs, stage, locale),
               sortValue: ({ durationMs }) => durationMs,
               align: "right",
             },
@@ -231,10 +199,22 @@ export function UnifiedWorkList({
   );
 }
 
+export function formatWorkListDuration(
+  durationMs: number | null,
+  stage: WorkStage,
+  locale: OperationsLocale,
+): string {
+  if (durationMs !== null) return formatRoundedDuration(durationMs);
+  return formatDisplayedDuration(
+    { durationMs: null, provenance: stage === "executing" ? "in_progress" : "unavailable" },
+    locale,
+  );
+}
+
 export function buildWorkListRows({
   allSpecs,
   allTasks,
-  changes,
+  changes: _changes,
   items,
   runs,
 }: {
@@ -244,7 +224,6 @@ export function buildWorkListRows({
   items: readonly WorkItem[];
   runs: readonly RunProjection[];
 }): WorkListRow[] {
-  const totalsByTask = taskTotals(runs);
   return items.map((item) => {
     const task = item.kind === "task" ? item.row : null;
     const macro = item.kind === "task" ? null : item.row;
@@ -257,7 +236,7 @@ export function buildWorkListRows({
             run.spec_id === macro.id ||
             (run.task_id !== null && macro.task_ids.includes(run.task_id))),
     );
-    const taskUsage = task ? totalsByTask.get(task.id) : null;
+    const taskUsage = task === null ? null : taskMetrics(task, relatedRuns);
     const progress = macro ? macroWorkProgress(macro, allSpecs, allTasks) : null;
     const macroRow = macro;
     const macroProgress = progress;
@@ -268,14 +247,9 @@ export function buildWorkListRows({
       return {
         item,
         stage: macroWorkStage(macroRow, allTasks),
-        originLabel: item.kind.toUpperCase(),
         risk: null,
         progress: macroWorkProgressLabel(macroRow.kind, macroProgress),
-        runCount: relatedRuns.filter((run) => run.run_kind === "run").length,
-        subrunCount: relatedRuns.filter((run) => run.run_kind === "subrun").length,
-        executionCount: macroRow.execution_count ?? 0,
-        taskCount: macroProgress.totalTasks,
-        durationMs: macroRow.duration_ms ?? null,
+        durationMs: macroRow.duration_ms ?? (hasProvenNoMacroActivity(macroRow) ? 0 : null),
         tokens: macroRow.usage.total.tokens.total ?? null,
         costBrl: macroRow.usage.total.cost.brl ?? null,
       };
@@ -283,16 +257,72 @@ export function buildWorkListRows({
     return {
       item,
       stage: taskWorkStage(task) ?? "planning",
-      originLabel: taskOriginLabel(taskOrigin(task, changes)),
       risk: task.risk ?? null,
       progress: `${Math.round(task.progress)}%`,
-      runCount: relatedRuns.filter((run) => run.run_kind === "run").length,
-      subrunCount: relatedRuns.filter((run) => run.run_kind === "subrun").length,
-      executionCount: task.execution_count ?? 0,
-      taskCount: 1,
-      durationMs: taskUsage?.durationMs ?? null,
+      durationMs: taskUsage?.durationMs ?? (hasProvenNoTaskActivity(task, relatedRuns) ? 0 : null),
       tokens: taskUsage?.tokens ?? null,
       costBrl: taskUsage?.costBrl ?? null,
     };
   });
 }
+
+/**
+ * A planned/cancelled Task with an explicit zero execution count has a known
+ * absence of activity. This is not the same as an incomplete Run page.
+ */
+function hasProvenNoTaskActivity(
+  task: DashboardTaskProjection,
+  relatedRuns: readonly RunProjection[],
+): boolean {
+  return (
+    relatedRuns.length === 0 &&
+    task.execution_started === false &&
+    (task.execution_count === 0 || task.execution_count === undefined) &&
+    (task.status === "planned" || task.status === "cancelled")
+  );
+}
+
+/** A macro with no materialized children or Runs has a known zero duration. */
+function hasProvenNoMacroActivity(macro: MacroProjection): boolean {
+  return (
+    macro.task_count === 0 &&
+    macro.execution_count === 0 &&
+    macro.run_count === 0 &&
+    macro.task_ids.length === 0 &&
+    macro.run_ids.length === 0
+  );
+}
+
+function workItemTypeLabel(kind: WorkItem["kind"], locale: OperationsLocale): string {
+  if (kind === "task") return locale === "pt-BR" ? "Tarefa" : "Task";
+  return kind.toUpperCase();
+}
+
+function taskMetrics(task: DashboardTaskProjection, runs: readonly RunProjection[]) {
+  if (task.telemetry !== null && task.telemetry !== undefined)
+    return {
+      durationMs: task.telemetry.duration_ms,
+      tokens: task.telemetry.tokens,
+      costBrl: task.telemetry.cost_brl,
+    };
+  return runs.reduce(
+    (total, run) => ({
+      durationMs: sumMetric(
+        total.durationMs,
+        run.phase === "execution" && run.parent_run_id === null ? operationalDurationMs(run) : null,
+      ),
+      tokens: sumMetric(total.tokens, run.usage.total.tokens.total),
+      costBrl: sumMetric(total.costBrl, run.usage.total.cost.brl),
+    }),
+    { durationMs: null, tokens: null, costBrl: null } as {
+      durationMs: number | null;
+      tokens: number | null;
+      costBrl: number | null;
+    },
+  );
+}
+
+function sumMetric(current: number | null, next: number | null): number | null {
+  if (current === null && next === null) return null;
+  return (current ?? 0) + (next ?? 0);
+}

package/templates/.agents/dashboard/modules/operations/src/react/conversation-rows.test.ts

@@ -20,9 +20,80 @@ describe("buildConversationRows", () => {
 
   it("keeps an interaction without a linked Run", () => {
     expect(buildConversationRows([interaction("EXEC-1", "CONV-A")], [])).toEqual([
-      expect.objectContaining({ id: "CONV-A", run_count: 0, models: [] }),
+      expect.objectContaining({ id: "CONV-A", run_count: 0, models: [], reasoning_efforts: [] }),
     ]);
   });
+
+  it("aggregates only observed models and efforts, leaving absent telemetry empty", () => {
+    const rows = buildConversationRows(
+      [interaction("EXEC-1", "CONV-A")],
+      [
+        {
+          ...run("RUN-1", "CONV-A", "EXEC-1"),
+          model: "gpt-5.6-terra,gpt-5.6-sol",
+          reasoning_effort: "medium,high",
+          effective_model: "gpt-5.6-terra,gpt-5.6-sol",
+          effective_reasoning_effort: "medium,high",
+        },
+        {
+          ...run("RUN-2", "CONV-A", "EXEC-1"),
+          model: "unknown",
+          reasoning_effort: null,
+        },
+      ],
+    );
+    expect(rows[0]).toMatchObject({
+      models: ["gpt-5.6-sol", "gpt-5.6-terra"],
+      reasoning_efforts: ["high", "medium"],
+    });
+  });
+
+  it("retains a task-delivery Run under its root conversation", () => {
+    const linkedDelivery = {
+      ...run("RUN-DELIVERY", "CONV-A", "EXEC-DELIVERY"),
+      entrypoint: "task",
+      task_id: "TASK-1",
+      model: "gpt-5.6-terra",
+      reasoning_effort: null,
+    } as RunProjection;
+    const [row] = buildConversationRows(
+      [
+        interaction("EXEC-1", "CONV-A"),
+        {
+          ...interaction("EXEC-DELIVERY", "CONV-UNRELATED"),
+          kind: "delivery",
+          origin: { type: "task", task_id: "TASK-1" },
+        } as ExecutionProjection,
+      ],
+      [linkedDelivery],
+    );
+    expect(row).toMatchObject({ run_count: 1, models: ["gpt-5.6-terra"], reasoning_efforts: [] });
+  });
+
+  it("preserves explicit terminal lifecycle elapsed without replacing source duration", () => {
+    const linked = {
+      ...run("RUN-1", "CONV-A", "EXEC-1"),
+      duration_ms: 60_000,
+      source_duration_ms: 60_000,
+      lifecycle_elapsed_ms: 90_000,
+    } as RunProjection;
+    const [row] = buildConversationRows([interaction("EXEC-1", "CONV-A")], [linked]);
+    expect(row).toMatchObject({ duration_ms: 60_000, lifecycle_elapsed_ms: 90_000 });
+  });
+
+  it("uses terminal lifecycle elapsed only when the conversation has no factual duration", () => {
+    const interactionRow = interaction("EXEC-1", "CONV-A");
+    const lifecycleOnly = {
+      ...run("RUN-1", "CONV-A", "EXEC-1"),
+      duration_ms: null,
+      source_duration_ms: null,
+      status: "completed",
+      started_at: "2026-07-28T10:00:00.000Z",
+      finished_at: "2026-07-28T10:01:00.000Z",
+    } as RunProjection;
+    const [row] = buildConversationRows([interactionRow], [lifecycleOnly]);
+    expect(row).toMatchObject({ duration_ms: 60_000, duration_provenance: "lifecycle_elapsed" });
+  });
 });
 
 function interaction(id: string, conversation_id: string): ExecutionProjection {

package/templates/.agents/dashboard/modules/operations/src/react/conversation-rows.ts

@@ -1,5 +1,5 @@
 import type { ExecutionProjection, RunProjection } from "../contracts.js";
-import { operationalDurationMs } from "./operation-duration.js";
+import { displayedDuration } from "./operation-duration.js";
 
 export interface ConversationRow {
   id: string;
@@ -8,7 +8,12 @@ export interface ConversationRow {
   execution_count: number;
   status: string;
   duration_ms: number | null;
+  duration_provenance: "factual" | "lifecycle_elapsed" | "unavailable";
+  total_tokens: number | null;
+  cost_brl: number | null;
   models: string[];
+  reasoning_efforts: string[];
+  lifecycle_elapsed_ms?: number | null;
 }
 
 /** Conversations are lifecycle interactions, never a phase-only Run projection. */
@@ -31,11 +36,11 @@ export function buildConversationRows(
         ...new Map(
           runs
             .filter(
-              (run) =>
-                run.entrypoint === "conversation" &&
-                run.task_id === null &&
-                (executionIds.has(run.execution_id ?? "") ||
-                  (run.execution_id === null && run.conversation_id === id)),
+              // A conversation can continue into a Task delivery. Its Runs
+              // retain the root conversation_id but legitimately have a Task
+              // entrypoint/task_id and a delivery Execution. Link by the
+              // conversation ID so that continuation is not dropped.
+              (run) => run.conversation_id === id || executionIds.has(run.execution_id ?? ""),
             )
             .map((run) => [run.id, run]),
         ).values(),
@@ -45,15 +50,34 @@ export function buildConversationRows(
           .filter((value): value is string => value !== null)
           .sort()
           .at(-1) ?? "";
-      const durations = linked
+      const durationPresentations = linked
         .filter((run) => run.run_kind !== "subrun" && run.parent_run_id == null)
-        .flatMap((run) => {
-          const duration = operationalDurationMs(run);
-          return duration === null ? [] : [duration];
-        });
+        .map((run) => displayedDuration(run));
+      const factualDurations = durationPresentations.flatMap(({ durationMs, provenance }) =>
+        provenance === "factual" && durationMs !== null ? [durationMs] : [],
+      );
+      const lifecycleDurations = durationPresentations.flatMap(({ durationMs, provenance }) =>
+        provenance === "lifecycle_elapsed" && durationMs !== null ? [durationMs] : [],
+      );
+      const sumKnown = (values: readonly (number | null)[]) => {
+        const known = values.filter((value): value is number => value !== null);
+        return known.length === 0 ? null : known.reduce((sum, value) => sum + value, 0);
+      };
       const latestExecution = [...executionRows].sort((left, right) =>
         (right.created_at ?? "").localeCompare(left.created_at ?? ""),
       )[0] as ExecutionProjection;
+      const explicitLifecycleElapsed = linked
+        .map(
+          (run) =>
+            (run as RunProjection & { lifecycle_elapsed_ms?: number | null }).lifecycle_elapsed_ms,
+        )
+        .find((value) => value !== undefined);
+      const durationProvenance: ConversationRow["duration_provenance"] =
+        factualDurations.length > 0
+          ? "factual"
+          : lifecycleDurations.length > 0
+            ? "lifecycle_elapsed"
+            : "unavailable";
       return {
         id,
         latest_started_at: latest ?? "",
@@ -61,15 +85,52 @@ export function buildConversationRows(
         execution_count: executionRows.length,
         status: latestExecution.status,
         duration_ms:
-          durations.length === 0 ? null : durations.reduce((sum, value) => sum + value, 0),
-        models: [
-          ...new Set(linked.map((run) => run.effective_model ?? run.model).filter(isKnownModel)),
-        ].sort(),
+          factualDurations.length > 0
+            ? factualDurations.reduce((sum, value) => sum + value, 0)
+            : lifecycleDurations.length > 0
+              ? lifecycleDurations.reduce((sum, value) => sum + value, 0)
+              : null,
+        duration_provenance: durationProvenance,
+        total_tokens: sumKnown(linked.map((run) => run.usage?.total.tokens.total ?? null)),
+        cost_brl: sumKnown(linked.map((run) => run.usage?.total.cost.brl ?? null)),
+        // `model` and `reasoning_effort` originate from canonical Run telemetry.
+        // Do not promote configuration defaults or requested values into an
+        // observed conversation value.
+        models: uniqueKnownValues(
+          linked.flatMap((run) => splitObservedValues(run.effective_model ?? run.model)),
+        ),
+        reasoning_efforts: uniqueKnownValues(
+          linked.flatMap((run) =>
+            splitObservedValues(run.effective_reasoning_effort ?? run.reasoning_effort),
+          ),
+        ),
+        ...(explicitLifecycleElapsed === undefined
+          ? {}
+          : {
+              lifecycle_elapsed_ms:
+                isTerminalStatus(latestExecution.status) &&
+                typeof explicitLifecycleElapsed === "number"
+                  ? explicitLifecycleElapsed
+                  : null,
+            }),
       };
     })
     .sort((left, right) => right.latest_started_at.localeCompare(left.latest_started_at));
 }
 
-function isKnownModel(model: string | null): model is string {
-  return model !== null && model.trim() !== "" && model.toLowerCase() !== "unknown";
+function isTerminalStatus(status: string): boolean {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+function uniqueKnownValues(values: readonly string[]): string[] {
+  return [...new Set(values.filter(isKnownObservedValue))].sort();
+}
+
+/** SQLite's complete conversation page compacts multiple observed values with commas. */
+function splitObservedValues(value: string | null | undefined): string[] {
+  return typeof value === "string" ? value.split(",").map((item) => item.trim()) : [];
+}
+
+function isKnownObservedValue(value: string): boolean {
+  return value !== "" && value.toLowerCase() !== "unknown";
 }

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