@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/period-summary.css

@@ -0,0 +1,12 @@
+.operations-period-summary .ui-table-heading {
+  min-width: 96px;
+}
+
+.operations-period-summary .ui-table th:first-child .ui-table-heading {
+  min-width: 120px;
+}
+
+.operations-period-summary .ui-table td,
+.operations-period-summary .ui-table th {
+  white-space: nowrap;
+}

package/templates/.agents/dashboard/modules/operations/src/react/period-summary.test.ts

@@ -0,0 +1,472 @@
+import { describe, expect, it } from "vitest";
+import { LEGACY_EFFORT_SNAPSHOT } from "../contracts.js";
+import { effortMetricTotals } from "./execution-metrics.js";
+import { exportRowsWithDurationHours } from "./export/ExcelExportAction.js";
+import { formatPeriod, periodTotalDurationMs } from "./PeriodSummaryTable.js";
+import {
+  aggregatePeriodSummary,
+  averagePeriodSummaryRows,
+  summarizePeriodRows,
+} from "./period-summary.js";
+
+const data = {
+  prds: [
+    { created_at: "2026-01-10T10:00:00.000Z" },
+    { created_at: "2026-01-10T12:00:00.000Z" },
+    { created_at: "2026-02-03T10:00:00.000Z" },
+  ],
+  specs: [{ created_at: "2026-01-10T10:00:00.000Z" }],
+  tasks: [
+    {
+      created_at: "2026-01-10T10:00:00.000Z",
+      result: { evidence_ids: ["EVD-1", "EVD-2"] },
+      test_count: 3,
+    },
+    { created_at: "2026-02-03T10:00:00.000Z", result: null, test_count: 2 },
+  ],
+  runs: [
+    {
+      id: "RUN-1",
+      started_at: "2026-01-10T10:00:00.000Z",
+      finished_at: "2026-01-10T10:01:00.000Z",
+      duration_ms: 60_000,
+      source_duration_ms: 60_000,
+      usage: { total: { tokens: { total: 100 }, cost: { brl: 1.5 } } },
+    },
+    {
+      id: "RUN-2",
+      started_at: "2026-02-03T10:00:00.000Z",
+      finished_at: "2026-02-03T10:02:00.000Z",
+      duration_ms: 120_000,
+      source_duration_ms: 120_000,
+      usage: { total: { tokens: { total: 250 }, cost: { brl: 2.5 } } },
+    },
+  ],
+};
+
+describe("aggregatePeriodSummary", () => {
+  it("uses the authoritative daily legacy snapshot once, then only post-cutoff effort", () => {
+    const usage = { total: { tokens: { total: null }, cost: { brl: null } } };
+    const runs = [
+      {
+        id: "BEFORE",
+        started_at: "2026-08-02T03:13:59.000Z",
+        finished_at: null,
+        duration_ms: 9_999_999,
+        source_duration_ms: 9_999_999,
+        usage,
+      },
+      {
+        id: "AFTER",
+        started_at: "2026-08-02T03:14:00.000Z",
+        finished_at: null,
+        duration_ms: 649_516,
+        source_duration_ms: 649_516,
+        usage,
+      },
+      {
+        id: "AFTER",
+        started_at: "2026-08-02T03:14:00.000Z",
+        finished_at: null,
+        duration_ms: 9_999_999,
+        source_duration_ms: 9_999_999,
+        usage,
+      },
+    ];
+    const rows = aggregatePeriodSummary(
+      { prds: [], specs: [], tasks: [], runs },
+      "day",
+      undefined,
+      true,
+    );
+    const cutoff = rows.find((row) => row.key === LEGACY_EFFORT_SNAPSHOT.cutoffDay);
+
+    expect(cutoff?.durationMs).toBe(5_459_027);
+    expect((summarizePeriodRows(rows).durationMs ?? 0) / 3_600_000).toBeCloseTo(63.871028, 6);
+  });
+
+  it("keeps the period summary and export on observed source duration only", () => {
+    const usage = { total: { tokens: { total: null }, cost: { brl: null } } };
+    const runs = [
+      {
+        id: "ROOT-OBSERVED",
+        phase: "execution" as const,
+        parent_run_id: null,
+        started_at: "2026-08-01T10:00:00.000Z",
+        finished_at: "2026-08-01T10:01:00.000Z",
+        source_duration_ms: 3_600_000,
+        duration_ms: 3_600_000,
+        usage,
+      },
+      {
+        id: "ROOT-RECONCILED",
+        phase: "execution" as const,
+        parent_run_id: null,
+        started_at: "2026-08-01T10:00:00.000Z",
+        finished_at: "2026-08-01T10:01:00.000Z",
+        source_duration_ms: null,
+        duration_ms: 1_800_000,
+        duration_provenance: "reconciled" as const,
+        usage,
+      },
+      {
+        id: "ROOT-LEGACY",
+        phase: "execution" as const,
+        parent_run_id: null,
+        started_at: "2026-08-01T10:00:00.000Z",
+        finished_at: "2026-08-01T10:01:00.000Z",
+        source_duration_ms: null,
+        duration_ms: 900_000,
+        duration_provenance: "legacy_inferred" as const,
+        usage,
+      },
+      {
+        id: "CHILD",
+        phase: "execution" as const,
+        parent_run_id: "ROOT-OBSERVED",
+        started_at: "2026-08-01T10:00:00.000Z",
+        finished_at: "2026-08-01T12:00:00.000Z",
+        source_duration_ms: 7_200_000,
+        duration_ms: 7_200_000,
+        usage,
+      },
+      // The 230.1h lifecycle timestamp span must not become analytical duration or coverage.
+      {
+        id: "OUTLIER",
+        phase: "execution" as const,
+        parent_run_id: null,
+        started_at: "2026-08-01T00:00:00.000Z",
+        finished_at: "2026-08-10T14:06:00.000Z",
+        source_duration_ms: null,
+        duration_ms: 828_360_000,
+        duration_provenance: "estimated" as const,
+        usage,
+      },
+    ];
+    const bigNumber = effortMetricTotals(runs).durationMs;
+    const [period] = aggregatePeriodSummary({ prds: [], specs: [], tasks: [], runs }, "day");
+
+    expect(bigNumber).toBe(10_800_000);
+    expect(period?.durationMs).toBe(bigNumber);
+    expect(exportRowsWithDurationHours([{ durationMs: period?.durationMs ?? null }])).toEqual([
+      { durationHours: 3 },
+    ]);
+  });
+
+  it("groups and sums all operation metrics by day", () => {
+    expect(aggregatePeriodSummary(data, "day")).toEqual([
+      {
+        key: "2026-02-03",
+        prds: 1,
+        specs: 0,
+        tasks: 1,
+        tasksCreated: 1,
+        tasksActive: 0,
+        taskDaysActive: 0,
+        runs: 1,
+        tests: 2,
+        evidences: 0,
+        durationMs: 120_000,
+        tokens: 250,
+        costBrl: 2.5,
+      },
+      {
+        key: "2026-01-10",
+        prds: 2,
+        specs: 1,
+        tasks: 1,
+        tasksCreated: 1,
+        tasksActive: 0,
+        taskDaysActive: 0,
+        runs: 1,
+        tests: 3,
+        evidences: 2,
+        durationMs: 60_000,
+        tokens: 100,
+        costBrl: 1.5,
+      },
+    ]);
+  });
+
+  it("rolls daily values up to month and year", () => {
+    expect(
+      aggregatePeriodSummary(data, "month").map((row) => [row.key, row.prds, row.tokens]),
+    ).toEqual([
+      ["2026-02", 1, 250],
+      ["2026-01", 2, 100],
+    ]);
+    expect(aggregatePeriodSummary(data, "year")).toEqual([
+      {
+        key: "2026",
+        prds: 3,
+        specs: 1,
+        tasks: 2,
+        tasksCreated: 2,
+        tasksActive: 0,
+        taskDaysActive: 0,
+        runs: 2,
+        tests: 5,
+        evidences: 2,
+        durationMs: 180_000,
+        tokens: 350,
+        costBrl: 4,
+      },
+    ]);
+  });
+
+  it("uses the America/Sao_Paulo day on both sides of 03:00Z", () => {
+    const rows = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-BEFORE-SP-MIDNIGHT",
+            task_id: "TASK-ACTIVE-ON-TWO-DAYS",
+            started_at: "2026-07-16T02:59:59.000Z",
+            finished_at: null,
+            duration_ms: 1_000,
+            usage: { total: { tokens: { total: 10 }, cost: { brl: 1 } } },
+          },
+          {
+            id: "RUN-AFTER-SP-MIDNIGHT",
+            task_id: "TASK-ACTIVE-ON-TWO-DAYS",
+            started_at: "2026-07-16T03:00:00.000Z",
+            finished_at: null,
+            duration_ms: 2_000,
+            usage: { total: { tokens: { total: 20 }, cost: { brl: 2 } } },
+          },
+        ],
+      },
+      "day",
+    );
+    expect(
+      rows.map((row) => [
+        row.key,
+        row.runs,
+        row.tasksCreated,
+        row.tasksActive,
+        row.taskDaysActive,
+        row.tokens,
+        row.costBrl,
+      ]),
+    ).toEqual([
+      ["2026-07-16", 1, 0, 1, 1, 20, 2],
+      ["2026-07-15", 1, 0, 1, 1, 10, 1],
+    ]);
+    expect(summarizePeriodRows(rows).taskDaysActive).toBe(2);
+  });
+
+  it("uses the resolved display cost when pricing settings override recorded cost", () => {
+    const rows = aggregatePeriodSummary(data, "year", (runId) => (runId === "RUN-1" ? 10 : null));
+    expect(rows[0]?.costBrl).toBe(10);
+  });
+
+  it("sums recorded duration even when Runs overlap", () => {
+    const rows = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-A",
+            started_at: "2026-01-10T08:00:00.000Z",
+            finished_at: "2026-01-10T12:00:00.000Z",
+            duration_ms: 4 * 3_600_000,
+            source_duration_ms: 4 * 3_600_000,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+          {
+            id: "RUN-B",
+            started_at: "2026-01-10T10:00:00.000Z",
+            finished_at: "2026-01-10T14:00:00.000Z",
+            duration_ms: 4 * 3_600_000,
+            source_duration_ms: 4 * 3_600_000,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+        ],
+      },
+      "day",
+    );
+    expect(rows[0]?.durationMs).toBe(8 * 3_600_000);
+  });
+
+  it("uses only root execution duration while retaining all-phase tokens and cost", () => {
+    const rows = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-CONVERSATION",
+            phase: "conversation",
+            parent_run_id: null,
+            started_at: "2026-01-10T07:00:00.000Z",
+            finished_at: "2026-01-10T08:00:00.000Z",
+            duration_ms: 60 * 60_000,
+            usage: { total: { tokens: { total: 120 }, cost: { brl: 0.25 } } },
+          },
+          {
+            id: "RUN-PLAN",
+            phase: "planning",
+            started_at: "2026-01-10T08:00:00.000Z",
+            finished_at: "2026-01-10T14:00:00.000Z",
+            duration_ms: 6 * 3_600_000,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+          {
+            id: "RUN-EXEC",
+            phase: "execution",
+            parent_run_id: null,
+            started_at: "2026-01-10T14:00:00.000Z",
+            finished_at: "2026-01-10T16:00:00.000Z",
+            duration_ms: 2 * 3_600_000,
+            source_duration_ms: 2 * 3_600_000,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+          {
+            id: "RUN-SUB",
+            phase: "execution",
+            parent_run_id: "RUN-EXEC",
+            started_at: "2026-01-10T14:30:00.000Z",
+            finished_at: "2026-01-10T15:00:00.000Z",
+            duration_ms: 30 * 60_000,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+        ],
+      },
+      "year",
+    );
+    expect(rows[0]).toMatchObject({
+      durationMs: 2 * 3_600_000,
+      tokens: 120,
+      costBrl: 0.25,
+      runs: 4,
+    });
+  });
+
+  it("uses the source measurement for each activity day instead of lifecycle elapsed time", () => {
+    const rows = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-SOURCE-DURATION",
+            phase: "execution",
+            started_at: "2026-07-29T10:00:00.000Z",
+            // This deliberately large lifecycle span must not enter analytics.
+            finished_at: "2026-07-31T09:09:21.600Z",
+            duration_ms: null,
+            source_duration_ms: 42_000,
+            usage: { total: { tokens: { total: 20 }, cost: { brl: 1.25 } } },
+          },
+        ],
+      },
+      "day",
+    );
+    expect(rows).toEqual([
+      expect.objectContaining({ key: "2026-07-29", durationMs: 42_000, tokens: 20, costBrl: 1.25 }),
+    ]);
+  });
+
+  it("uses source duration instead of a projected duration in period rows", () => {
+    const rows = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-PROJECTED",
+            phase: "execution",
+            started_at: "2026-08-01T10:00:00.000Z",
+            finished_at: "2026-08-01T10:00:00.000Z",
+            duration_ms: 413_659_026,
+            source_duration_ms: 31 * 3_600_000,
+            usage: { total: { tokens: { total: 10 }, cost: { brl: 1 } } },
+          },
+        ],
+      },
+      "day",
+    );
+
+    expect(rows).toEqual([
+      expect.objectContaining({
+        key: "2026-08-01",
+        durationMs: 31 * 3_600_000,
+        tokens: 10,
+        costBrl: 1,
+      }),
+    ]);
+  });
+
+  it("does not double count a duplicated projected Run", () => {
+    const run = {
+      id: "RUN-1",
+      phase: "execution",
+      started_at: "2026-01-10T10:00:00.000Z",
+      finished_at: "2026-01-10T10:01:00.000Z",
+      duration_ms: 60_000,
+      source_duration_ms: 60_000,
+      usage: { total: { tokens: { total: 100 }, cost: { brl: 1.5 } } },
+    };
+    expect(
+      aggregatePeriodSummary({ prds: [], specs: [], tasks: [], runs: [run, run] }, "day")[0],
+    ).toMatchObject({ runs: 1, durationMs: 60_000, tokens: 100, costBrl: 1.5 });
+  });
+
+  it("calculates averages per displayed period and preserves unavailable usage", () => {
+    const rows = aggregatePeriodSummary(data, "day");
+    expect(averagePeriodSummaryRows(rows)).toEqual({
+      tasks: 1,
+      specs: 0.5,
+      prds: 1.5,
+      durationMs: 90_000,
+      tokens: 175,
+      costBrl: 2,
+    });
+
+    const unavailable = aggregatePeriodSummary(
+      {
+        prds: [],
+        specs: [],
+        tasks: [],
+        runs: [
+          {
+            id: "RUN-NULL",
+            started_at: "2026-01-10T10:00:00.000Z",
+            finished_at: null,
+            duration_ms: null,
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+        ],
+      },
+      "day",
+    );
+    expect(averagePeriodSummaryRows(unavailable)).toMatchObject({
+      durationMs: null,
+      tokens: null,
+      costBrl: null,
+    });
+  });
+});
+
+describe("formatPeriod", () => {
+  it("keeps monthly periods in sortable YYYY-MM format", () => {
+    expect(formatPeriod("2026-06", "month", "pt-BR")).toBe("2026-06");
+    expect(formatPeriod("2025-12", "month", "en-US")).toBe("2025-12");
+  });
+});
+
+describe("period total duration display", () => {
+  it("shows zero for an empty execution total without changing missing Run telemetry", () => {
+    expect(periodTotalDurationMs(null, 0)).toBe(0);
+    expect(periodTotalDurationMs(null, null)).toBeNull();
+    expect(periodTotalDurationMs(60_000, 10)).toBe(60_000);
+  });
+});