@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -0,0 +1,168 @@
+import type { ComponentProps } from "react";
+import type { OperationsProjection } from "../contracts.js";
+import {
+  ChangeTable,
+  ConversationTable,
+  DecisionTable,
+  ExecutionTable,
+  RunTable,
+} from "./EntityTables.js";
+import { OperationsEntityPager } from "./OperationsPageNavigation.js";
+import type { OperationsView } from "./operations-page-filters.js";
+import { PeriodSummaryTable } from "./PeriodSummaryTable.js";
+import type { OperationsLocale } from "./status-labels.js";
+import { UnifiedWorkBoard } from "./UnifiedWorkBoard.js";
+import { UnifiedWorkList } from "./UnifiedWorkList.js";
+import type { WorkStage, WorkTypeFilter } from "./work-board-model.js";
+
+type WorkBoardProps = ComponentProps<typeof UnifiedWorkBoard>;
+
+export interface OperationsMainContentProps {
+  boardKindTotals?: WorkBoardProps["boardKindTotals"] | undefined;
+  boardStates?: WorkBoardProps["boardStates"] | undefined;
+  boardTotals?: WorkBoardProps["boardTotals"] | undefined;
+  changes: ComponentProps<typeof ChangeTable>["rows"];
+  conversationExecutions: ComponentProps<typeof ConversationTable>["executions"];
+  conversationRuns: ComponentProps<typeof ConversationTable>["rows"];
+  currency: "BRL" | "USD";
+  data: OperationsProjection;
+  entityPage?:
+    | {
+        offset: number;
+        total: number | null;
+        loading: boolean;
+        error: string | null;
+        aggregation?: "canonical_entity" | "page_partial" | undefined;
+      }
+    | undefined;
+  executions: ComponentProps<typeof ExecutionTable>["rows"];
+  factualCostPeriods?: ComponentProps<typeof PeriodSummaryTable>["factualCostPeriods"] | undefined;
+  includeLegacyEffort: boolean;
+  locale: OperationsLocale;
+  onBoardTypeChange?: ((kind: WorkTypeFilter) => void) | undefined;
+  onEntityPageChange?: ((offset: number) => void) | undefined;
+  onLoadMoreBoard?: ((stage: WorkStage) => void) | undefined;
+  onWorkListTypeChange?: ((kind: WorkTypeFilter) => void) | undefined;
+  onOpenDocument: WorkBoardProps["onOpenDocument"];
+  onOpenTask: WorkBoardProps["onOpenTask"];
+  onPriorityChange: WorkBoardProps["onPriorityChange"];
+  prds: WorkBoardProps["prds"];
+  resolveRunCost?: ComponentProps<typeof PeriodSummaryTable>["resolveRunCost"] | undefined;
+  runs: ComponentProps<typeof RunTable>["rows"];
+  specs: WorkBoardProps["specs"];
+  summaryPopulation: ComponentProps<typeof PeriodSummaryTable>["data"];
+  tasks: WorkBoardProps["tasks"];
+  view: OperationsView;
+}
+
+export function OperationsMainContent({
+  boardKindTotals,
+  boardStates,
+  boardTotals,
+  changes,
+  conversationExecutions,
+  conversationRuns,
+  currency,
+  data,
+  entityPage,
+  executions,
+  factualCostPeriods,
+  includeLegacyEffort,
+  locale,
+  onBoardTypeChange,
+  onEntityPageChange,
+  onLoadMoreBoard,
+  onWorkListTypeChange,
+  onOpenDocument,
+  onOpenTask,
+  onPriorityChange,
+  prds,
+  resolveRunCost,
+  runs,
+  specs,
+  summaryPopulation,
+  tasks,
+  view,
+}: OperationsMainContentProps) {
+  return (
+    <section className="operations-content">
+      {view === "work-kanban" ? (
+        <UnifiedWorkBoard
+          allPrds={data.prds}
+          allSpecs={data.specs}
+          allTasks={data.tasks}
+          boardTotals={boardTotals}
+          boardKindTotals={boardKindTotals}
+          boardStates={boardStates}
+          changes={data.changes}
+          locale={locale}
+          onOpenDocument={onOpenDocument}
+          onOpenTask={onOpenTask}
+          onPriorityChange={onPriorityChange}
+          onLoadMore={onLoadMoreBoard}
+          onTypeChange={onBoardTypeChange}
+          prds={prds}
+          runs={data.runs}
+          specs={specs}
+          tasks={tasks}
+        />
+      ) : null}
+      {view === "work-list" ? (
+        <UnifiedWorkList
+          allSpecs={data.specs}
+          allTasks={data.tasks}
+          changes={data.changes}
+          locale={locale}
+          onOpenDocument={onOpenDocument}
+          onOpenTask={onOpenTask}
+          prds={prds}
+          runs={data.runs}
+          specs={specs}
+          tasks={tasks}
+          onTypeChange={onWorkListTypeChange}
+        />
+      ) : null}
+      {view === "changes" ? <ChangeTable locale={locale} rows={changes} /> : null}
+      {view === "executions" ? (
+        <ExecutionTable
+          canonical={entityPage?.aggregation !== "page_partial"}
+          locale={locale}
+          rows={executions}
+        />
+      ) : null}
+      {view === "runs" ? <RunTable locale={locale} rows={runs} /> : null}
+      {view === "conversations" ? (
+        <ConversationTable
+          canonical={entityPage?.aggregation !== "page_partial"}
+          executions={conversationExecutions}
+          locale={locale}
+          rows={conversationRuns}
+        />
+      ) : null}
+      {entityPage &&
+      ["runs", "executions", "conversations", "changes", "decisions"].includes(view) ? (
+        <OperationsEntityPager
+          entityPage={entityPage}
+          locale={locale}
+          onChange={onEntityPageChange}
+        />
+      ) : null}
+      {view === "decisions" ? <DecisionTable locale={locale} rows={data.decisions} /> : null}
+      {view === "daily" || view === "monthly" || view === "yearly" ? (
+        <PeriodSummaryTable
+          data={summaryPopulation}
+          currency={currency}
+          granularity={view === "daily" ? "day" : view === "monthly" ? "month" : "year"}
+          locale={locale}
+          resolveRunCost={resolveRunCost}
+          includeLegacyEffort={includeLegacyEffort}
+          {...(factualCostPeriods === undefined ? {} : { factualCostPeriods })}
+          legacyRange={data.filters}
+          {...(data.summary.periods === undefined
+            ? {}
+            : { manifestDailyPeriods: data.summary.periods.daily })}
+        />
+      ) : null}
+    </section>
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/OperationsOverview.helpers.tsx

@@ -36,6 +36,20 @@ export function averageObserved(values: readonly (number | null)[]): number | nu
     : observed.reduce((total, value) => total + value, 0) / observed.length;
 }
 
+export function overviewMetricAverages(
+  totals: { durationMs: number | null; tokens: number | null; costBrl: number | null },
+  selectedCount: number | null,
+) {
+  if (selectedCount === null || selectedCount === 0) {
+    return { durationMs: null, tokens: null, costBrl: null };
+  }
+  return {
+    durationMs: totals.durationMs === null ? null : totals.durationMs / selectedCount,
+    tokens: totals.tokens === null ? null : totals.tokens / selectedCount,
+    costBrl: totals.costBrl === null ? null : totals.costBrl / selectedCount,
+  };
+}
+
 export function findLatestTaskCreatedAt(
   tasks: readonly Pick<OperationsProjection["tasks"][number], "created_at">[],
 ): string | null {
@@ -118,7 +132,21 @@ export function aggregateTaskMetrics(
 
 export function aggregateMacroMetrics(
   macros: readonly (Pick<MacroProjection, "id" | "title" | "kind" | "run_ids"> &
-    Partial<Pick<MacroProjection, "duration_ms" | "usage" | "run_count">>)[],
+    Partial<
+      Pick<
+        MacroProjection,
+        | "duration_ms"
+        | "duration_provenance"
+        | "usage"
+        | "run_count"
+        | "root_execution_run_ids"
+        | "observed_root_duration_ms"
+        | "observed_lifecycle_duration_ms"
+        | "duration_coverage"
+        | "lifecycle_duration_coverage"
+        | "lifecycle_duration_provenance"
+      >
+    >)[],
   runs: readonly {
     id: string;
     phase: string;
@@ -135,11 +163,38 @@ export function aggregateMacroMetrics(
   resolveRunCostBrl?: ((runId: string) => number | null) | undefined,
 ) {
   return macros.map((macro) => {
+    // A materialized macro metric is already deduplicated by the backend.
+    // Do not reconstruct it from a partial Run page or shared descendants.
+    const materializedCoverage = macro.lifecycle_duration_coverage ?? macro.duration_coverage;
+    if (materializedCoverage !== undefined) {
+      const materializedDuration =
+        macro.observed_lifecycle_duration_ms ??
+        macro.observed_root_duration_ms ??
+        macro.duration_ms ??
+        null;
+      return {
+        id: macro.id,
+        title: macro.title,
+        durationMs: materializedDuration,
+        durationProvenance:
+          macro.lifecycle_duration_provenance ??
+          (materializedDuration === null ? "unavailable" : "observed"),
+        durationEligible: materializedCoverage.eligible_runs,
+        durationKnown: materializedCoverage.known_runs,
+        tokens: macro.usage?.total.tokens.total ?? null,
+        costBrl: macro.usage?.total.cost.brl ?? null,
+        runCount: macro.run_count ?? macro.root_execution_run_ids?.length ?? 0,
+      };
+    }
     if (runs.length === 0) {
       return {
         id: macro.id,
         title: macro.title,
         durationMs: macro.duration_ms ?? null,
+        durationProvenance:
+          macro.duration_provenance ?? (macro.duration_ms === null ? "unavailable" : "observed"),
+        durationEligible: null,
+        durationKnown: null,
         tokens: macro.usage?.total.tokens.total ?? null,
         costBrl: macro.usage?.total.cost.brl ?? null,
         runCount: macro.run_count ?? 0,
@@ -155,6 +210,11 @@ export function aggregateMacroMetrics(
       id: macro.id,
       title: macro.title,
       durationMs: sumObserved(relatedDurationRuns.map((run) => run.duration_ms)),
+      durationProvenance: relatedDurationRuns.some((run) => run.duration_ms !== null)
+        ? "observed"
+        : "unavailable",
+      durationEligible: relatedDurationRuns.length,
+      durationKnown: relatedDurationRuns.filter((run) => run.duration_ms !== null).length,
       tokens: sumObserved(relatedUsageRuns.map((run) => run.usage.total.tokens.total)),
       costBrl: sumObserved(
         relatedUsageRuns.map((run) =>
@@ -176,7 +236,8 @@ export function macroClassificationStats(
       key: "empty",
       label: isPortuguese ? "Sem tarefas" : "Without tasks",
       color: macroClassificationColors.empty,
-      count: macros.filter((macro) => macro.task_count === 0).length,
+      count: macros.filter((macro) => macro.task_count === 0 && macro.rework_run_count === 0)
+        .length,
     },
     {
       key: "structured",
@@ -197,21 +258,49 @@ export function summarizeTopEntityMetrics(
   topEntities: readonly EntityMetric[],
   allEntities: readonly EntityMetric[],
 ) {
-  const durationMs = topEntities.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
-  const totalDurationMs = allEntities.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
+  const measuredTop = topEntities.filter((entity) => entity.durationMs !== null);
+  const measuredAll = allEntities.filter((entity) => entity.durationMs !== null);
+  const durationMs =
+    measuredTop.length === 0
+      ? null
+      : measuredTop.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
+  const totalDurationMs =
+    measuredAll.length === 0
+      ? null
+      : measuredAll.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
   return {
     durationMs,
-    durationShare: totalDurationMs === 0 ? 0 : durationMs / totalDurationMs,
+    durationShare:
+      durationMs === null || totalDurationMs === null || totalDurationMs === 0
+        ? 0
+        : durationMs / totalDurationMs,
     runCount: topEntities.reduce((sum, entity) => sum + entity.runCount, 0),
     tokens: sumObserved(topEntities.map((entity) => entity.tokens)),
     costBrl: sumObserved(topEntities.map((entity) => entity.costBrl)),
   };
 }
 
-interface EntityMetric {
+export function selectTopEntities(entities: readonly EntityMetric[], limit = 5): EntityMetric[] {
+  return entities
+    .toSorted((left, right) => {
+      const availabilityOrder =
+        Number(right.durationMs !== null) - Number(left.durationMs !== null);
+      if (availabilityOrder !== 0) return availabilityOrder;
+      const durationOrder = (right.durationMs ?? 0) - (left.durationMs ?? 0);
+      if (durationOrder !== 0) return durationOrder;
+      const runOrder = right.runCount - left.runCount;
+      return runOrder !== 0 ? runOrder : left.id.localeCompare(right.id);
+    })
+    .slice(0, Math.max(0, limit));
+}
+
+export interface EntityMetric {
   id: string;
   title: string;
   durationMs: number | null;
+  durationProvenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  durationEligible?: number | null;
+  durationKnown?: number | null;
   tokens: number | null;
   costBrl: number | null;
   runCount: number;