@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -1,9 +1,47 @@
 import { describe, expect, it } from "vitest";
-import type { DashboardTaskProjection, RunProjection } from "../contracts.js";
-import { buildWorkListRows } from "./UnifiedWorkList.js";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+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 +56,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 +68,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 +87,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);
+  });
 });

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

@@ -8,10 +8,11 @@ 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 +32,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 +50,7 @@ export function UnifiedWorkList({
   runs,
   specs,
   tasks,
+  onTypeChange,
 }: {
   allSpecs: readonly MacroProjection[];
   allTasks: readonly DashboardTaskProjection[];
@@ -65,6 +62,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 +84,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 +116,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 +141,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 +202,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 +227,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 +239,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 +250,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 +260,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,12 @@ export function buildConversationRows(
         ...new Map(
           runs
             .filter(
+              // 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.entrypoint === "conversation" &&
-                run.task_id === null &&
-                (executionIds.has(run.execution_id ?? "") ||
-                  (run.execution_id === null && run.conversation_id === id)),
+                run.conversation_id === id || executionIds.has(run.execution_id ?? ""),
             )
             .map((run) => [run.id, run]),
         ).values(),
@@ -45,15 +51,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 +86,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";
 }