@zaip-ai/cli 1.0.7 → 1.0.8

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,168 @@ 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).toContain('costBrl: currency === "USD" ? metric.total_cost_usd ?? null : 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 +328,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("keeps a fully unavailable metric null", () => {
-    expect(averageObserved([null, null])).toBeNull();
+  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("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 +421,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 +431,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 +595,9 @@ describe("aggregateMacroMetrics", () => {
         id: "SPEC-1",
         title: "Planejamento",
         durationMs: 300,
+        durationProvenance: "observed",
+        durationEligible: 2,
+        durationKnown: 2,
         tokens: 30,
         costBrl: 9,
         runCount: 2,
@@ -262,6 +611,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 +621,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 +652,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 +686,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 +696,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 +796,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" }),