@zaip-ai/cli 1.0.7 → 1.3.0

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;

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

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 import {
   allPhaseMetricTotals,
@@ -7,7 +8,6 @@ import {
 import {
   aggregateMacroMetrics,
   aggregateTaskMetrics,
-  averageObserved,
   countExecutionDays,
   findLatestCreatedAt,
   findLatestTaskCreatedAt,
@@ -15,10 +15,17 @@ import {
   formatTokenThroughputHint,
   macroClassificationStats,
   macroStatusDistribution,
+  overviewMetricAverages,
   overviewText,
+  partialOverviewMetrics,
+  resolveOverviewCostTotal,
+  runsForOverviewView,
+  selectedOverviewCount,
+  selectTopEntities,
   statusColors,
   summarizeTopEntityMetrics,
   summarizeTopTaskMetrics,
+  taskMetricAverages,
   taskStatusDistribution,
 } from "./OperationsOverview.js";
 
@@ -53,7 +60,7 @@ describe("global card population", () => {
     expect(executionMetricTotals([root, child])).toMatchObject({ durationMs: null });
   });
 
-  it("sums deduplicated observed root and Sub-Run duration, excluding estimated or absent telemetry", () => {
+  it("keeps delegated Sub-Run duration out of Operations root execution totals", () => {
     const root = {
       ...run("TASK-1", 99, 1, 1),
       id: "RUN-ROOT-OBS",
@@ -91,7 +98,170 @@ describe("global card population", () => {
   });
 });
 
+describe("partial overview charts", () => {
+  it("renders aggregate Status and Classification rather than incomplete task arrays", () => {
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    expect(source).toMatch(/const taskStatusStats\s*=\s*aggregateTaskStatusCounts/);
+    expect(source).toMatch(/aggregateTaskRiskCounts\s*\?/);
+    expect(source).not.toContain("{overviewIsPartial ? (");
+  });
+});
+
+describe("overview aggregate source", () => {
+  it("keeps aggregate-only Top 5 USD factual and leaves a missing value unavailable", () => {
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    expect(source).toMatch(
+      /costBrl:\s*currency === "USD"\s*\?\s*\(metric\.total_cost_usd \?\? null\)\s*:\s*metric\.cost_brl/,
+    );
+    expect(source).toContain("topEntitiesCost === null");
+  });
+
+  it("uses the factual compact USD summary when its Run rows are intentionally absent", () => {
+    expect(
+      resolveOverviewCostTotal({
+        currency: "USD",
+        factualSnapshotTotal: 8731.92,
+        overviewView: "tasks",
+        resolvedRunTotal: null,
+        operationsBrlTotal: 47_589,
+      }),
+    ).toBe(8731.92);
+  });
+
+  it("does not relabel a BRL-only Operations aggregate as USD", () => {
+    expect(
+      resolveOverviewCostTotal({
+        currency: "USD",
+        factualSnapshotTotal: null,
+        overviewView: "tasks",
+        resolvedRunTotal: null,
+        operationsBrlTotal: 47_589,
+      }),
+    ).toBeNull();
+  });
+
+  it("uses a selected macro's factual USD total rather than the global Task snapshot", () => {
+    expect(
+      resolveOverviewCostTotal({
+        currency: "USD",
+        factualSnapshotTotal: 8731.92,
+        macroCostTotal: 13.4,
+        overviewView: "specs",
+        resolvedRunTotal: 12,
+        operationsBrlTotal: 47_589,
+      }),
+    ).toBe(13.4);
+  });
+
+  it("keeps summary metrics as the KPI source after a detail response", () => {
+    const summary = {
+      overview_metrics: {
+        partial: false,
+        task_count: 15,
+        spec_count: 15,
+        prd_count: 5,
+        duration_ms: 15_000,
+        execution_day_count: 2,
+        tokens: 150,
+        cost_brl: 15,
+      },
+    };
+    expect(partialOverviewMetrics({ summary } as never)).toMatchObject({
+      task_count: 15,
+      cost_brl: 15,
+    });
+
+    expect(
+      partialOverviewMetrics({
+        summary: { overview_metrics: { ...summary.overview_metrics, partial: true } },
+      } as never),
+    ).toMatchObject({ task_count: 15, spec_count: 15, prd_count: 5 });
+  });
+
+  it("keeps the global aggregate across Operations, Cost Monitor, and Kanban navigations", () => {
+    const partial = partialOverviewMetrics({
+      summary: {
+        overview_metrics: {
+          partial: true,
+          task_count: 265,
+          task_status_counts: { executing: 171, ready: 94 },
+          task_risk_counts: { standard: 157, lite: 108 },
+          duration_ms: 265_000,
+          execution_day_count: 1,
+          tokens: 265,
+          cost_brl: 26.5,
+        },
+      },
+    } as never);
+    const full = partialOverviewMetrics({
+      summary: {
+        overview_metrics: {
+          partial: false,
+          task_count: 265,
+          task_status_counts: { executing: 171, ready: 94 },
+          task_risk_counts: { standard: 157, lite: 108 },
+          duration_ms: 265_000,
+          execution_day_count: 1,
+          tokens: 265,
+          cost_brl: 26.5,
+        },
+      },
+    } as never);
+
+    // The view-local collections can be incomplete on all three routes; cards
+    // and classifications remain attached to the filtered global aggregate.
+    expect(partial).toMatchObject({ task_count: 265 });
+    expect(
+      Object.values(partial?.task_status_counts ?? {}).reduce((sum, count) => sum + count, 0),
+    ).toBe(265);
+    expect(
+      Object.values(partial?.task_risk_counts ?? {}).reduce((sum, count) => sum + count, 0),
+    ).toBe(265);
+    expect(full).toMatchObject({ task_count: 265, cost_brl: 26.5 });
+    const filteredKanbanTasks = Array.from({ length: 171 }, (_, index) => ({
+      status: "executing" as const,
+      spec_id: null,
+      risk: index < 157 ? "standard" : "lite",
+    }));
+    expect(filteredKanbanTasks).toHaveLength(171);
+    expect(
+      taskStatusDistribution(filteredKanbanTasks, "pt-BR").reduce(
+        (total, row) => total + row.count,
+        0,
+      ),
+    ).toBe(171);
+    expect(filteredKanbanTasks.filter((task) => task.risk === "standard")).toHaveLength(157);
+  });
+});
+
 describe("execution average summary", () => {
+  it("calculates fast overview task averages from the filtered aggregate totals", () => {
+    expect(taskMetricAverages({ durationMs: 12_600_000, tokens: 63_000, costBrl: 126 }, 3)).toEqual(
+      { durationMs: 4_200_000, tokens: 21_000, costBrl: 42 },
+    );
+  });
+
+  it("keeps aggregate task averages unavailable when the task count is unavailable", () => {
+    expect(taskMetricAverages({ durationMs: 12_600_000, tokens: 63_000, costBrl: 126 }, 0)).toEqual(
+      {
+        durationMs: null,
+        tokens: null,
+        costBrl: null,
+      },
+    );
+  });
+
+  it("uses the summary task count when the fast overview omits task records", () => {
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const durationCard = source.slice(
+      source.indexOf("hint={formatExecutionAverageHint("),
+      source.indexOf("label={text.totalExecutionTime}"),
+    );
+
+    expect(durationCard).toContain("taskCount ?? 0");
+    expect(durationCard).not.toContain("tasks.length");
+  });
+
   it("formats average duration per task and per active execution day", () => {
     expect(
       countExecutionDays([
@@ -160,13 +330,52 @@ describe("statusColors", () => {
   });
 });
 
-describe("averageObserved", () => {
-  it("averages only measured values", () => {
-    expect(averageObserved([10, null, 20])).toBe(15);
+describe("overviewMetricAverages", () => {
+  it("uses aggregate totals and the selected population, preserving unavailable totals", () => {
+    expect(overviewMetricAverages({ durationMs: 900, tokens: 90, costBrl: 9 }, 3)).toEqual({
+      durationMs: 300,
+      tokens: 30,
+      costBrl: 3,
+    });
+    expect(overviewMetricAverages({ durationMs: null, tokens: 90, costBrl: null }, 3)).toEqual({
+      durationMs: null,
+      tokens: 30,
+      costBrl: null,
+    });
+    expect(overviewMetricAverages({ durationMs: 900, tokens: 90, costBrl: 9 }, 0)).toEqual({
+      durationMs: null,
+      tokens: null,
+      costBrl: null,
+    });
+  });
+
+  it("passes unknown totals through as unavailable instead of coercing them to zero", () => {
+    const averages = overviewMetricAverages({ durationMs: null, tokens: null, costBrl: null }, 3);
+    expect(averages).toEqual({ durationMs: null, tokens: null, costBrl: null });
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    expect(source).toContain(
+      "durationMs: totalDurationMetric, tokens: totalTokensMetric, costBrl: totalCostMetric",
+    );
+    expect(source).toContain("formatEntityDuration(averageDuration, locale)");
+    expect(source).not.toContain("executionMetrics.durationMs ?? 0");
+  });
+});
+
+describe("selectedOverviewCount", () => {
+  it("uses the same server-selected SPEC/PRD population for quick and full projections", () => {
+    const metrics = { selected_counts: { specs: 4, prds: 2 }, task_count: 9 } as never;
+    expect(selectedOverviewCount("specs", metrics, 99)).toBe(4);
+    expect(selectedOverviewCount("prds", metrics, 99)).toBe(2);
+    expect(selectedOverviewCount("tasks", metrics, 99)).toBe(9);
   });
 
-  it("keeps a fully unavailable metric null", () => {
-    expect(averageObserved([null, null])).toBeNull();
+  it("falls back only when a selected count is absent", () => {
+    expect(selectedOverviewCount("specs", undefined, 0)).toBe(0);
+    expect(overviewMetricAverages({ durationMs: 120, tokens: null, costBrl: 6 }, 0)).toEqual({
+      durationMs: null,
+      tokens: null,
+      costBrl: null,
+    });
   });
 });
 
@@ -214,7 +423,7 @@ describe("aggregateTaskMetrics", () => {
     ]);
   });
 
-  it("uses the same execution Run population as periods, including child agent work", () => {
+  it("uses only root execution duration while retaining all related usage", () => {
     const metrics = aggregateTaskMetrics(
       [{ id: "TASK-1", title: "Primeira" }],
       [
@@ -224,15 +433,154 @@ describe("aggregateTaskMetrics", () => {
     );
 
     expect(metrics[0]).toMatchObject({
-      durationMs: 9_960_000,
+      durationMs: 9_360_000,
       tokens: 110,
       costBrl: 11,
+      runCount: 1,
+    });
+  });
+});
+
+describe("selectTopEntities", () => {
+  it("keeps the complete selected SPEC population, ordering observed duration before unavailable", () => {
+    const selected = selectTopEntities([
+      entityMetric("SPEC-1", 300, 3, 30, 1),
+      entityMetric("SPEC-2", 200, 2, 20, 1),
+      entityMetric("SPEC-3", null, 30, 300, 8),
+      entityMetric("SPEC-4", null, 20, 200, 6),
+      entityMetric("SPEC-5", null, 10, 100, 4),
+      entityMetric("SPEC-6", null, 5, 50, 2),
+    ]);
+
+    expect(selected).toHaveLength(5);
+    expect(selected.map((entity) => entity.id)).toEqual([
+      "SPEC-1",
+      "SPEC-2",
+      "SPEC-3",
+      "SPEC-4",
+      "SPEC-5",
+    ]);
+    expect(summarizeTopEntityMetrics(selected, selected).durationMs).toBe(500);
+  });
+
+  it("retains four selected SPEC entries when only one has observed duration", () => {
+    const selected = selectTopEntities([
+      entityMetric("SPEC-OBSERVED", 600, 10, 1, 1),
+      entityMetric("SPEC-NO-RUNS", null, null, null, 0),
+      entityMetric("SPEC-UNKNOWN-A", null, 8, 2, 2),
+      entityMetric("SPEC-UNKNOWN-B", null, 4, 1, 1),
+    ]);
+    expect(selected.map((entity) => entity.id)).toEqual([
+      "SPEC-OBSERVED",
+      "SPEC-UNKNOWN-A",
+      "SPEC-UNKNOWN-B",
+      "SPEC-NO-RUNS",
+    ]);
+    expect(summarizeTopEntityMetrics(selected, selected)).toMatchObject({
+      durationMs: 600,
+      durationShare: 1,
+      runCount: 4,
+      tokens: 22,
+      costBrl: 4,
+    });
+  });
+
+  it("keeps all-unavailable selected SPECs and reports duration as unavailable, never zero", () => {
+    const selected = selectTopEntities([
+      entityMetric("SPEC-A", null, 4, 1, 1),
+      entityMetric("SPEC-B", null, 3, 2, 1),
+      entityMetric("SPEC-C", null, null, null, 0),
+    ]);
+    expect(selected).toHaveLength(3);
+    expect(summarizeTopEntityMetrics(selected, selected)).toMatchObject({
+      durationMs: null,
+      durationShare: 0,
       runCount: 2,
+      tokens: 7,
+      costBrl: 3,
     });
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    expect(source).toContain("formatEntityDuration(topEntitiesSummary.durationMs, locale)");
+  });
+});
+
+describe("Top 5 presentation", () => {
+  it("keeps coverage and provenance internal while using the scoped subtitle", () => {
+    const source = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    expect(source).toContain('"Tempo de ciclo de vida (Runs-raiz, todas as fases)."');
+    expect(source).toContain('"Lifecycle time (root Runs, all phases)."');
+    expect(source).toContain("<span>{`#${index + 1} ${entity.id.slice(-4)}`}</span>");
+    expect(source).not.toContain("operations-top-coverage");
+    expect(source).not.toContain("duração comprovada");
+    expect(source).not.toContain("durationSourceLabel");
   });
 });
 
 describe("aggregateMacroMetrics", () => {
+  it("uses the materialized macro duration instead of partial Run rows", () => {
+    const [metric] = aggregateMacroMetrics(
+      [
+        {
+          id: "SPEC-MATERIALIZED",
+          title: "Materializada",
+          kind: "spec",
+          run_ids: ["RUN-COMPLETE", "RUN-PLANNING", "RUN-UNKNOWN", "RUN-CHILD"],
+          root_execution_run_ids: ["RUN-COMPLETE"],
+          run_count: 4,
+          observed_lifecycle_duration_ms: 120,
+          observed_root_duration_ms: 999,
+          duration_ms: 999,
+          duration_provenance: "observed",
+          duration_coverage: {
+            eligible_runs: 3,
+            known_runs: 2,
+            unknown_runs: 1,
+            coverage_ratio: 2 / 3,
+          },
+          lifecycle_duration_coverage: {
+            eligible_runs: 4,
+            known_runs: 3,
+            unknown_runs: 1,
+            coverage_ratio: 3 / 4,
+          },
+          lifecycle_duration_provenance: "observed",
+        },
+      ],
+      [run(null, 999, 1, 1, { id: "RUN-PARTIAL", specId: "SPEC-MATERIALIZED" })],
+    );
+    expect(metric).toMatchObject({
+      durationMs: 120,
+      durationProvenance: "observed",
+      durationEligible: 4,
+      durationKnown: 3,
+      runCount: 4,
+    });
+  });
+
+  it("keeps related metrics populated when the overview switches from Tasks to SPECs to PRDs", () => {
+    const tasks = [{ id: "TASK-1" }, { id: "TASK-2" }];
+    const specs = [{ id: "SPEC-1", title: "SPEC", kind: "spec", run_ids: ["RUN-SPEC"] }];
+    const prds = [{ id: "PRD-1", title: "PRD", kind: "prd", run_ids: ["RUN-PRD"] }];
+    const runs = [
+      run("TASK-1", 100, 10, 1, { id: "RUN-TASK" }),
+      run(null, 200, 20, 2, { id: "RUN-SPEC", specId: "SPEC-1" }),
+      run(null, 300, 30, 3, { id: "RUN-PRD", prdId: "PRD-1" }),
+    ];
+
+    expect(runsForOverviewView("tasks", tasks as never, [], runs as never)).toHaveLength(1);
+    const specMetrics = aggregateMacroMetrics(
+      specs as never,
+      runsForOverviewView("specs", tasks as never, specs as never, runs as never),
+    );
+    const prdMetrics = aggregateMacroMetrics(
+      prds as never,
+      runsForOverviewView("prds", tasks as never, prds as never, runs as never),
+    );
+
+    expect(specMetrics[0]).toMatchObject({ durationMs: 200, tokens: 20, costBrl: 2, runCount: 1 });
+    expect(prdMetrics[0]).toMatchObject({ durationMs: 300, tokens: 30, costBrl: 3, runCount: 1 });
+  });
+
   it("aggregates only Runs linked to each macro and honors resolved costs", () => {
     const metrics = aggregateMacroMetrics(
       [{ id: "SPEC-1", title: "Planejamento", kind: "spec", run_ids: ["RUN-DECLARED"] }],
@@ -249,6 +597,9 @@ describe("aggregateMacroMetrics", () => {
         id: "SPEC-1",
         title: "Planejamento",
         durationMs: 300,
+        durationProvenance: "observed",
+        durationEligible: 2,
+        durationKnown: 2,
         tokens: 30,
         costBrl: 9,
         runCount: 2,
@@ -262,6 +613,7 @@ describe("macroClassificationStats", () => {
     const stats = macroClassificationStats(
       [
         { task_count: 0, rework_run_count: 0 },
+        { task_count: 0, rework_run_count: 2 },
         { task_count: 2, rework_run_count: 0 },
         { task_count: 3, rework_run_count: 1 },
       ],
@@ -271,8 +623,9 @@ describe("macroClassificationStats", () => {
     expect(stats.map(({ key, label, count }) => ({ key, label, count }))).toEqual([
       { key: "empty", label: "Sem tarefas", count: 1 },
       { key: "structured", label: "Com tarefas", count: 1 },
-      { key: "rework", label: "Com retrabalho", count: 1 },
+      { key: "rework", label: "Com retrabalho", count: 2 },
     ]);
+    expect(stats.reduce((total, row) => total + row.count, 0)).toBe(4);
   });
 });
 
@@ -301,7 +654,7 @@ describe("taskStatusDistribution", () => {
     );
 
     expect(distribution.map(({ key, label, count }) => ({ key, label, count }))).toEqual([
-      { key: "definition", label: "Definição (PRD + Requisitos)", count: 0 },
+      { key: "definition", label: "Definição (PRD + Requisitos)", count: 2 },
       { key: "planning", label: "Planejamento (SPEC + Change)", count: 0 },
       { key: "ready", label: "Pronto para Executar", count: 2 },
       { key: "executing", label: "Execução", count: 1 },
@@ -335,7 +688,7 @@ describe("taskStatusDistribution", () => {
     );
 
     expect(visible.map(({ key, count }) => ({ key, count }))).toEqual([
-      { key: "definition", count: 0 },
+      { key: "definition", count: 1 },
       { key: "planning", count: 0 },
       { key: "ready", count: 2 },
       { key: "executing", count: 1 },
@@ -345,7 +698,7 @@ describe("taskStatusDistribution", () => {
       { key: "cancelled", count: 1 },
       { key: "failed", count: 1 },
     ]);
-    expect(visible.reduce((total, item) => total + item.count, 0)).toBe(7);
+    expect(visible.reduce((total, item) => total + item.count, 0)).toBe(8);
   });
 });
 
@@ -445,7 +798,7 @@ describe("summarizeTopTaskMetrics", () => {
     ).toMatchObject({ tokens: null, costBrl: null });
   });
 
-  it("uses all observed execution duration but all related phases for top-task usage", () => {
+  it("uses root execution duration but all related phases for top-task usage", () => {
     const root = run("TASK-1", 2_000, 10, 1, { id: "RUN-ROOT" });
     const child = {
       ...run("TASK-1", 1_000, 20, 2, { id: "RUN-CHILD" }),