@zaip-ai/cli 1.3.0 → 1.3.2

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

@@ -36,6 +36,13 @@ export function averageObserved(values: readonly (number | null)[]): number | nu
     : observed.reduce((total, value) => total + value, 0) / observed.length;
 }
 
+export function sumKnownOverviewMetric(values: readonly (number | null)[]): number | null {
+  return values.reduce<number | null>(
+    (total, value) => (value === null ? total : (total ?? 0) + value),
+    null,
+  );
+}
+
 export function overviewMetricAverages(
   totals: { durationMs: number | null; tokens: number | null; costBrl: number | null },
   selectedCount: number | null,
@@ -50,6 +57,13 @@ export function overviewMetricAverages(
   };
 }
 
+export function taskMetricAverages(
+  totals: { durationMs: number | null; tokens: number | null; costBrl: number | null },
+  taskCount: number | null,
+) {
+  return overviewMetricAverages(totals, taskCount);
+}
+
 export function findLatestTaskCreatedAt(
   tasks: readonly Pick<OperationsProjection["tasks"][number], "created_at">[],
 ): string | null {
@@ -298,7 +312,13 @@ export interface EntityMetric {
   id: string;
   title: string;
   durationMs: number | null;
-  durationProvenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  durationProvenance?:
+    | "observed"
+    | "reconciled"
+    | "legacy_inferred"
+    | "shared_creation_allocation"
+    | "estimated"
+    | "unavailable";
   durationEligible?: number | null;
   durationKnown?: number | null;
   tokens: number | null;
@@ -306,6 +326,90 @@ export interface EntityMetric {
   runCount: number;
 }
 
+type OverviewView = "tasks" | "specs" | "prds";
+
+export function selectedOverviewCount(
+  view: OverviewView,
+  overviewMetrics: OperationsProjection["summary"]["overview_metrics"] | undefined,
+  fallback: number,
+): number | null {
+  if (view === "specs") return overviewMetrics?.selected_counts?.specs ?? fallback;
+  if (view === "prds") return overviewMetrics?.selected_counts?.prds ?? fallback;
+  return overviewMetrics?.task_count ?? fallback;
+}
+
+export function selectedMacroMetricTotals(entityMetrics: readonly EntityMetric[]) {
+  return {
+    durationMs: sumKnownOverviewMetric(entityMetrics.map((entity) => entity.durationMs)),
+    tokens: sumKnownOverviewMetric(entityMetrics.map((entity) => entity.tokens)),
+    costBrl: sumKnownOverviewMetric(entityMetrics.map((entity) => entity.costBrl)),
+  };
+}
+
+export function scopedOverviewMetric(
+  view: OverviewView,
+  macroValue: number | null | undefined,
+  taskValue: number | null,
+): number | null {
+  return view === "tasks" ? taskValue : (macroValue ?? null);
+}
+
+export function canonicalMacroMetric(
+  hasCanonicalAggregate: boolean,
+  canonicalValue: number | null | undefined,
+  fallbackValue: number | null,
+): number | null {
+  return hasCanonicalAggregate ? (canonicalValue ?? null) : fallbackValue;
+}
+
+/** Selects currency totals without treating Operations' BRL aggregate as USD. */
+export function resolveOverviewCostTotal({
+  currency,
+  factualSnapshotTotal,
+  macroCostTotal,
+  overviewView,
+  resolvedRunTotal,
+  operationsBrlTotal,
+}: {
+  currency: "BRL" | "USD";
+  factualSnapshotTotal: number | null | undefined;
+  macroCostTotal?: number | null | undefined;
+  overviewView?: OverviewView;
+  resolvedRunTotal: number | null;
+  operationsBrlTotal: number | null;
+}): number | null {
+  if (overviewView !== undefined && overviewView !== "tasks") return macroCostTotal ?? null;
+  if (factualSnapshotTotal !== null && factualSnapshotTotal !== undefined)
+    return factualSnapshotTotal;
+  if (resolvedRunTotal !== null) return resolvedRunTotal;
+  return currency === "BRL" ? operationsBrlTotal : null;
+}
+
+export function partialOverviewMetrics(data: OperationsProjection) {
+  return data.summary.overview_metrics;
+}
+
+export function runsForOverviewView(
+  view: OverviewView,
+  tasks: OperationsProjection["tasks"],
+  macros: OperationsProjection["specs"] | OperationsProjection["prds"],
+  runs: OperationsProjection["runs"],
+): OperationsProjection["runs"] {
+  if (view === "tasks") {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    return runs.filter((run) => run.task_id !== null && taskIds.has(run.task_id));
+  }
+  const macroIds = new Set(macros.map((macro) => macro.id));
+  const declaredRunIds = new Set(macros.flatMap((macro) => macro.run_ids));
+  return runs.filter(
+    (run) =>
+      declaredRunIds.has(run.id) ||
+      (view === "specs"
+        ? run.spec_id !== null && macroIds.has(run.spec_id)
+        : run.prd_id !== null && macroIds.has(run.prd_id)),
+  );
+}
+
 export function summarizeTopTaskMetrics(
   topTasks: readonly { id: string; durationMs: number | null }[],
   runs: readonly {
@@ -416,9 +520,10 @@ export function overviewText(locale: OperationsLocale) {
   } as const;
 }
 
-export function countExecutionDays(runs: readonly { started_at: string }[]): number {
+export function countExecutionDays(runs: readonly { started_at?: string }[]): number {
   const days = new Set<string>();
   for (const run of runs) {
+    if (run.started_at === undefined) continue;
     const date = new Date(run.started_at);
     if (Number.isNaN(date.getTime())) continue;
     days.add(`${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`);

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

@@ -0,0 +1,55 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+  canonicalMacroMetric,
+  scopedOverviewMetric,
+  selectedMacroMetricTotals,
+} from "./OperationsOverview.js";
+
+describe("macro overview metrics", () => {
+  it("keeps narrowed SPEC/PRD totals scoped to returned entities", () => {
+    const totals = selectedMacroMetricTotals([
+      { id: "SPEC-1", title: "One", durationMs: null, tokens: 40, costBrl: 3, runCount: 1 },
+      { id: "SPEC-2", title: "Two", durationMs: null, tokens: null, costBrl: null, runCount: 0 },
+    ]);
+    expect(totals).toEqual({ durationMs: null, tokens: 40, costBrl: 3 });
+    expect(totals.durationMs).not.toBe(83.4 * 3_600_000);
+    expect(totals.tokens).not.toBe(2_200_000_000);
+  });
+
+  it("never substitutes global Task metrics for an unavailable macro metric", () => {
+    expect(scopedOverviewMetric("specs", null, 83.4 * 3_600_000)).toBeNull();
+    expect(scopedOverviewMetric("prds", undefined, 2_200_000_000)).toBeNull();
+    expect(scopedOverviewMetric("tasks", null, 83.4 * 3_600_000)).toBe(83.4 * 3_600_000);
+    expect(canonicalMacroMetric(true, null, 83.4 * 3_600_000)).toBeNull();
+    expect(canonicalMacroMetric(true, undefined, 2_200_000_000)).toBeNull();
+    expect(canonicalMacroMetric(false, undefined, 2_200_000_000)).toBe(2_200_000_000);
+  });
+
+  it("renders returned macros even when some durations are unavailable", () => {
+    const overview = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const topPanel = readFileSync(
+      new URL("OperationsOverviewTopPanel.tsx", import.meta.url),
+      "utf8",
+    );
+    expect(overview).toContain('overviewView !== "tasks" && aggregateTopMacros.length > 0');
+    expect(overview).not.toContain('overviewView !== "tasks" && runs.length === 0');
+    expect(topPanel).toContain("topEntities.map((entity, index)");
+    expect(topPanel).toMatch(/entity\.durationMs === null\s*\?\s*"0%"/);
+    expect(topPanel).toContain('" is-duration-unavailable"');
+  });
+
+  it("keeps Top 5 coverage and provenance internal while using the scoped subtitle", () => {
+    const overview = readFileSync(new URL("OperationsOverview.tsx", import.meta.url), "utf8");
+    const topPanel = readFileSync(
+      new URL("OperationsOverviewTopPanel.tsx", import.meta.url),
+      "utf8",
+    );
+    expect(overview).toContain('"Tempo de ciclo de vida (Runs-raiz, todas as fases)."');
+    expect(overview).toContain('"Lifecycle time (root Runs, all phases)."');
+    expect(topPanel).toContain(`<span>{\`#\${index + 1} \${entity.id.slice(-4)}\`}</span>`);
+    expect(`${overview}\n${topPanel}`).not.toContain("operations-top-coverage");
+    expect(`${overview}\n${topPanel}`).not.toContain("duração comprovada");
+    expect(`${overview}\n${topPanel}`).not.toContain("durationSourceLabel");
+  });
+});

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

@@ -29,6 +29,9 @@ import {
   taskStatusDistribution,
 } from "./OperationsOverview.js";
 
+const readOverviewSource = (file = "OperationsOverview.tsx") =>
+  readFileSync(new URL(file, import.meta.url), "utf8");
+
 describe("global card population", () => {
   it("includes conversation and planning usage but excludes them from duration", () => {
     const runs = [
@@ -97,23 +100,22 @@ 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");
+    const source = readOverviewSource();
     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");
+    const source = readOverviewSource();
+    const topPanelSource = readOverviewSource("OperationsOverviewTopPanel.tsx");
     expect(source).toMatch(
       /costBrl:\s*currency === "USD"\s*\?\s*\(metric\.total_cost_usd \?\? null\)\s*:\s*metric\.cost_brl/,
     );
-    expect(source).toContain("topEntitiesCost === null");
+    expect(topPanelSource).toContain("topCost === null");
   });
 
   it("uses the factual compact USD summary when its Run rows are intentionally absent", () => {
@@ -208,8 +210,6 @@ describe("overview aggregate source", () => {
       },
     } 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),
@@ -252,13 +252,16 @@ describe("execution average summary", () => {
   });
 
   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 source = readOverviewSource();
     const durationCard = source.slice(
       source.indexOf("hint={formatExecutionAverageHint("),
-      source.indexOf("label={text.totalExecutionTime}"),
+      source.indexOf("label={", source.indexOf("hint={formatExecutionAverageHint(")),
     );
 
-    expect(durationCard).toContain("taskCount ?? 0");
+    expect(source).toContain(
+      'const metricPopulationCount = overviewView === "tasks" ? taskCount : selectedCount;',
+    );
+    expect(durationCard).toContain("metricPopulationCount ?? 0");
     expect(durationCard).not.toContain("tasks.length");
   });
 
@@ -329,7 +332,6 @@ describe("statusColors", () => {
     expect(statusColors.failed).toBe("#64748b");
   });
 });
-
 describe("overviewMetricAverages", () => {
   it("uses aggregate totals and the selected population, preserving unavailable totals", () => {
     expect(overviewMetricAverages({ durationMs: 900, tokens: 90, costBrl: 9 }, 3)).toEqual({
@@ -352,7 +354,7 @@ describe("overviewMetricAverages", () => {
   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");
+    const source = readOverviewSource();
     expect(source).toContain(
       "durationMs: totalDurationMetric, tokens: totalTokensMetric, costBrl: totalCostMetric",
     );
@@ -360,15 +362,17 @@ describe("overviewMetricAverages", () => {
     expect(source).not.toContain("executionMetrics.durationMs ?? 0");
   });
 });
-
 describe("selectedOverviewCount", () => {
+  it("hydrates extended macro aggregates when a SPEC or PRD card is selected", () => {
+    const source = readOverviewSource();
+    expect(source).toContain('if (view !== "tasks") onLoadMacroMetrics?.();');
+  });
   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({
@@ -499,20 +503,8 @@ describe("selectTopEntities", () => {
       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");
+    const source = readOverviewSource("OperationsOverviewTopPanel.tsx");
+    expect(source).toContain("duration(summary.durationMs, locale)");
   });
 });