@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/operations/src/server/quick-operations-projection.test.ts

@@ -0,0 +1,505 @@
+import { readFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
+import { type LifecycleManifestEvent, LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import { describe, expect, it } from "vitest";
+import { normalizeFilter } from "./filter.js";
+import {
+  aggregateTopTasks,
+  buildQuickOperationsProjection,
+  coverageFromRuns,
+  hybridLegacyDurationMetric,
+  macroInWindow,
+  manifestDailyPeriods,
+  summaryTopTasks,
+  taskCountsInWindow,
+  withExecutionDurations,
+} from "./quick-operations-projection.js";
+
+describe("quick Operations Top 5", () => {
+  it("excludes an orphan Run task ID while preserving canonical task metrics", () => {
+    expect(
+      aggregateTopTasks(
+        [
+          {
+            id: "RUN-ORPHAN",
+            task_id: "TASK-2026-07-17-20-36-PUBLIC-RUNTIME-ACTIVATION-N6P7",
+            phase: "execution",
+            duration_ms: 9_000,
+            total_tokens: 900,
+            cost: 9,
+          },
+          {
+            id: "RUN-CANONICAL",
+            task_id: "TASK-CANONICAL",
+            phase: "execution",
+            parent_run_id: null,
+            status: "completed",
+            started_at: "2026-08-06T10:00:00.000Z",
+            finished_at: "2026-08-06T10:00:01.000Z",
+            duration_ms: 1_522_376,
+            total_tokens: 100,
+            cost: 1,
+          },
+        ] as Parameters<typeof aggregateTopTasks>[0],
+        new Set(["TASK-CANONICAL"]),
+      ),
+    ).toEqual([
+      {
+        task_id: "TASK-CANONICAL",
+        duration_ms: 1_522_376,
+        total_tokens: 100,
+        cost_brl: 1,
+        run_count: 1,
+      },
+    ]);
+  });
+
+  it("uses observed root execution duration while retaining all Run usage metrics", () => {
+    expect(
+      aggregateTopTasks(
+        [
+          {
+            id: "RUN-ROOT-A",
+            task_id: "TASK-CANONICAL",
+            phase: "execution",
+            parent_run_id: null,
+            status: "completed",
+            started_at: "2026-08-06T10:00:00.000Z",
+            finished_at: "2026-08-06T10:19:50.000Z",
+            duration_ms: 1_522_376,
+            total_tokens: 100,
+            cost: 1,
+          },
+          {
+            id: "RUN-CHILD",
+            task_id: "TASK-CANONICAL",
+            phase: "execution",
+            parent_run_id: "RUN-ROOT-A",
+            status: "completed",
+            started_at: "2026-08-06T10:02:00.000Z",
+            finished_at: "2026-08-06T10:18:00.000Z",
+            duration_ms: 1_522_376,
+            total_tokens: 200,
+            cost: 2,
+          },
+          {
+            id: "RUN-ROOT-B",
+            task_id: "TASK-CANONICAL",
+            phase: "execution",
+            parent_run_id: null,
+            status: "completed",
+            started_at: "2026-08-06T10:30:00.000Z",
+            finished_at: "2026-08-06T10:31:45.000Z",
+            duration_ms: 1_522_376,
+            total_tokens: 300,
+            cost: 3,
+          },
+        ] as Parameters<typeof aggregateTopTasks>[0],
+        new Set(["TASK-CANONICAL"]),
+      ),
+    ).toEqual([
+      {
+        task_id: "TASK-CANONICAL",
+        duration_ms: 3_044_752,
+        total_tokens: 600,
+        cost_brl: 6,
+        run_count: 3,
+      },
+    ]);
+  });
+
+  it("re-ranks every period-bounded Run instead of merging daily Top 5 lists", () => {
+    const result = summaryTopTasks(
+      {
+        run_metrics: [
+          compactRun("RUN-A-1", "TASK-A", "2026-08-01T12:00:00.000Z", 6),
+          compactRun("RUN-A-2", "TASK-A", "2026-08-02T12:00:00.000Z", 6),
+          compactRun("RUN-B", "TASK-B", "2026-08-01T12:00:00.000Z", 10),
+          compactRun("RUN-C", "TASK-C", "2026-08-02T12:00:00.000Z", 10),
+        ],
+        periods: {
+          daily: {
+            // A daily Top 5 could omit TASK-A on both days; it is intentionally
+            // not used to build a multi-day ranking.
+            "2026-08-01": {
+              top_tasks: [
+                { task_id: "TASK-B", duration_ms: 10, total_tokens: 1, cost: 1, run_count: 1 },
+              ],
+            },
+            "2026-08-02": {
+              top_tasks: [
+                { task_id: "TASK-C", duration_ms: 10, total_tokens: 1, cost: 1, run_count: 1 },
+              ],
+            },
+          },
+        },
+      } as unknown as Parameters<typeof summaryTopTasks>[0],
+      { from: "2026-08-01T00:00:00.000Z", to: "2026-08-02T23:59:59.999Z" },
+      new Set(["TASK-A", "TASK-B", "TASK-C"]),
+    );
+
+    expect(result[0]).toMatchObject({ task_id: "TASK-A", duration_ms: 12, run_count: 2 });
+  });
+});
+
+function compactRun(id: string, taskId: string, startedAt: string, durationMs: number) {
+  return {
+    id,
+    task_id: taskId,
+    phase: "execution",
+    parent_run_id: null,
+    status: "completed",
+    started_at: startedAt,
+    finished_at: startedAt,
+    duration_ms: durationMs,
+    total_tokens: 1,
+    cost: 1,
+  };
+}
+
+describe("quick Operations completeness contract", () => {
+  it("marks the aggregate response as partial while retaining daily macro charts", () => {
+    const source = readFileSync(new URL("quick-operations-projection.ts", import.meta.url), "utf8");
+    expect(source).toContain("partial: true");
+    expect(source).toContain('manifest.readDailyReadModels("specs")');
+    expect(source).toContain('manifest.readDailyReadModels("prds")');
+    expect(source).toContain("prds,");
+    expect(source).toContain("specs,");
+  });
+});
+
+describe("quick Operations daily first fold", () => {
+  it("reads separate daily projections and never summary.json or Run/Sub-Run facts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "zaip-dashboard-quick-daily-"));
+    try {
+      const filesystem = new WorkspaceFileSystem(root);
+      const store = new LifecycleManifestStore(filesystem);
+      await store.replace([dailyEntity("task", "TASK-DAILY")]);
+      const reads: string[] = [];
+      const originalReadText = filesystem.readText.bind(filesystem);
+      filesystem.readText = async (path: string) => {
+        reads.push(path);
+        return originalReadText(path);
+      };
+      const projection = await buildQuickOperationsProjection(filesystem, {
+        version: 2,
+      } as WorkspaceLayout);
+      expect(projection.summary.task_count).toBe(1);
+      expect(projection.runs).toEqual([]);
+      expect(reads.some((path) => path.endsWith("lifecycle/summary.json"))).toBe(false);
+      expect(reads.some((path) => path.includes("/runs/") || path.includes("\\runs\\"))).toBe(
+        false,
+      );
+      expect(reads.some((path) => path.includes("lifecycle/views/overview-"))).toBe(true);
+      expect(reads.some((path) => path.includes("lifecycle/views/tasks/"))).toBe(true);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+function dailyEntity(kind: "task", id: string): LifecycleManifestEvent {
+  return {
+    schema_version: 1,
+    event_id: `event:${id}`,
+    occurred_at: "2026-08-09T12:00:00.000Z",
+    operation: "upsert",
+    entity: {
+      kind,
+      id,
+      title: id,
+      status: "completed",
+      risk: "lite",
+      priority: null,
+      updated_at: "2026-08-09T12:00:00.000Z",
+      relations: [],
+      usage: null,
+      data: { created_at: "2026-08-09T12:00:00.000Z", finished_at: "2026-08-09T12:00:00.000Z" },
+    },
+  };
+}
+
+describe("quick Operations coverage", () => {
+  it("keeps the complete legacy baseline separate from an unknown post-cutoff root", () => {
+    expect(
+      hybridLegacyDurationMetric(
+        [
+          { id: "PRE", started_at: "2026-08-02T03:00:00.000Z", duration_ms: 99_000 },
+          { id: "KNOWN", started_at: "2026-08-02T04:00:00.000Z", duration_ms: 2_000 },
+          { id: "UNKNOWN", started_at: "2026-08-03T12:00:00.000Z", duration_ms: null },
+        ],
+        { from: null, to: null },
+      ),
+    ).toEqual({
+      known_sum: 229_288_186,
+      unknown: 1,
+      complete: false,
+      coverage_ratio: 0.5,
+    });
+  });
+
+  it("unions overlapping post-cutoff root intervals like the Cost daily projection", () => {
+    expect(
+      hybridLegacyDurationMetric(
+        [
+          { id: "LEFT", started_at: "2026-08-07T12:00:00.000Z", duration_ms: 3_600_000 },
+          { id: "RIGHT", started_at: "2026-08-07T12:30:00.000Z", duration_ms: 3_600_000 },
+        ],
+        { from: "2026-08-07", to: "2026-08-07" },
+      ),
+    ).toEqual({ known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 });
+  });
+
+  it("keeps duration unavailable when filtered roots have no observed duration", () => {
+    const roots = [{ duration_ms: null, total_tokens: 20, cost: 1 }];
+    expect(roots.filter((run) => run.duration_ms !== null)).toHaveLength(0);
+    expect(coverageFromRuns(roots).duration).toBe(0);
+  });
+
+  it("uses the same filtered Run population independently for each metric", () => {
+    expect(
+      coverageFromRuns([
+        { duration_ms: 100, total_tokens: 200, cost: null },
+        { duration_ms: null, total_tokens: 300, cost: 4 },
+      ]),
+    ).toEqual({ duration: 0.5, tokens: 1, cost: 0.5 });
+  });
+
+  it("treats an empty period as complete instead of showing a false warning", () => {
+    expect(coverageFromRuns([])).toEqual({ duration: 1, tokens: 1, cost: 1 });
+  });
+
+  it("treats a persisted zero duration as known", () => {
+    expect(coverageFromRuns([{ duration_ms: 0, total_tokens: 0, cost: 0 }])).toEqual({
+      duration: 1,
+      tokens: 1,
+      cost: 1,
+    });
+  });
+});
+
+describe("quick Operations São Paulo period boundaries", () => {
+  it("keeps date-only 02–07 buckets literal and excludes 08", () => {
+    const periods = manifestDailyPeriods(
+      {
+        periods: {
+          daily: {
+            "2026-08-01": {},
+            "2026-08-02": {},
+            "2026-08-07": {},
+            "2026-08-08": {},
+          },
+        },
+      } as unknown as Parameters<typeof manifestDailyPeriods>[0],
+      normalizeFilter({ from: "2026-08-02", to: "2026-08-07" }).from,
+      normalizeFilter({ from: "2026-08-02", to: "2026-08-07" }).to,
+    );
+    expect(periods.map(([day]) => day)).toEqual(["2026-08-02", "2026-08-07"]);
+  });
+
+  it("re-buckets complete Run metrics by terminal day without moving entity counters", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = (tasks: number, runs: number, tokens: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks,
+      validations: 0,
+      evidences: 0,
+      runs,
+      usage: {
+        input_tokens: known(0),
+        output_tokens: known(0),
+        total_tokens: known(tokens),
+        cost: { ...known(tokens / 10), currency: "BRL" },
+      },
+      events: known(runs),
+    });
+    const summary = {
+      usage: { cost: { currency: "BRL" } },
+      periods: {
+        daily: {
+          "2026-08-06": period(2, 1, 100),
+          "2026-08-07": period(3, 1, 200),
+        },
+      },
+      run_metrics: [
+        {
+          id: "RUN-CROSSES-MIDNIGHT",
+          started_at: "2026-08-07T02:57:00.000Z",
+          finished_at: "2026-08-07T03:06:00.000Z",
+          total_tokens: 100,
+          cost: 10,
+          events: 1,
+        },
+        {
+          id: "RUN-SAME-DAY",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: "2026-08-07T12:10:00.000Z",
+          total_tokens: 200,
+          cost: 20,
+          events: 1,
+        },
+      ],
+    } as unknown as Parameters<typeof manifestDailyPeriods>[0];
+
+    const periods = Object.fromEntries(manifestDailyPeriods(summary, null, null));
+    expect(periods["2026-08-06"]).toMatchObject({
+      tasks: 2,
+      runs: 0,
+      usage: { total_tokens: { known_sum: 0 } },
+    });
+    expect(periods["2026-08-07"]).toMatchObject({
+      tasks: 3,
+      runs: 2,
+      usage: { total_tokens: { known_sum: 300 }, cost: { known_sum: 30 } },
+    });
+  });
+});
+
+describe("quick Operations daily duration", () => {
+  it("uses the hybrid duration source for each daily row", () => {
+    const periods = [
+      [
+        "2026-08-07",
+        {
+          duration: { known_sum: 999, unknown: 0, complete: true, coverage_ratio: 1 },
+        },
+      ],
+    ] as Parameters<typeof withExecutionDurations>[0];
+    const runs = [
+      {
+        id: "RUN-EXEC-KNOWN",
+        phase: "execution",
+        parent_run_id: null,
+        started_at: "2026-08-07T12:00:00.000Z",
+        duration_ms: 55_311_925,
+      },
+      {
+        id: "RUN-EXEC-UNKNOWN",
+        phase: "execution",
+        parent_run_id: null,
+        started_at: "2026-08-07T13:00:00.000Z",
+        duration_ms: null,
+      },
+      {
+        id: "RUN-EXEC-CHILD",
+        phase: "execution",
+        parent_run_id: "RUN-EXEC-KNOWN",
+        started_at: "2026-08-07T12:30:00.000Z",
+        duration_ms: 99_999_999,
+      },
+      {
+        id: "RUN-CONVERSATION",
+        phase: "conversation",
+        started_at: "2026-08-07T14:00:00.000Z",
+        duration_ms: 32_615_000,
+      },
+      {
+        id: "RUN-PLANNING",
+        phase: "planning",
+        started_at: "2026-08-07T15:00:00.000Z",
+        duration_ms: 6_084_000,
+      },
+    ] as Parameters<typeof withExecutionDurations>[1];
+
+    expect(withExecutionDurations(periods, runs)).toEqual({
+      "2026-08-07": {
+        duration: {
+          known_sum: 54_000_000,
+          unknown: 1,
+          complete: false,
+          coverage_ratio: 0.5,
+        },
+      },
+    });
+  });
+
+  it("keeps the immutable legacy day available without synthesizing a Run", () => {
+    const periods = [["2026-07-12", { runs: 0 }]] as Parameters<typeof withExecutionDurations>[0];
+
+    expect(withExecutionDurations(periods, [])).toMatchObject({
+      "2026-07-12": {
+        runs: 0,
+        duration: { known_sum: 8_339_738, unknown: 0, complete: true, coverage_ratio: 1 },
+      },
+    });
+  });
+});
+
+describe("quick Operations task population", () => {
+  it("keeps card, status, and risk cardinalities in the same bounded population", () => {
+    const counts = taskCountsInWindow(
+      [
+        {
+          status: "completed",
+          risk: "low",
+          updated_at: "2026-08-01T12:00:00.000Z",
+          data: { finished_at: "2026-08-01T12:00:00.000Z" },
+        },
+        {
+          status: "blocked",
+          risk: "high",
+          updated_at: "2026-07-20T12:00:00.000Z",
+          data: { finished_at: "2026-07-20T12:00:00.000Z" },
+        },
+        { status: "active", risk: null, updated_at: "2026-07-20T12:00:00.000Z", data: null },
+      ],
+      { from: "2026-08-01T00:00:00.000Z", to: "2026-08-07T23:59:59.999Z" },
+    );
+
+    expect(counts.total).toBe(1);
+    expect(Object.values(counts.statuses).reduce((sum, value) => sum + value, 0)).toBe(
+      counts.total,
+    );
+    expect(Object.values(counts.risks).reduce((sum, value) => sum + value, 0)).toBe(counts.total);
+    expect(counts.risks.unclassified).toBeUndefined();
+  });
+
+  it("uses the same temporal membership for active Tasks and PRD/SPEC cards", () => {
+    const today = { from: "2026-08-08T00:00:00.000Z", to: "2026-08-08T23:59:59.999Z" };
+    const yesterday = { from: "2026-08-07T00:00:00.000Z", to: "2026-08-07T23:59:59.999Z" };
+    const activeToday = {
+      status: "executing",
+      risk: "standard",
+      updated_at: "2026-08-08T12:00:00.000Z",
+    };
+    const activeYesterday = {
+      status: "blocked",
+      risk: "critical",
+      updated_at: "2026-08-07T12:00:00.000Z",
+    };
+    const olderActive = { status: "draft", risk: "lite", updated_at: "2026-08-06T12:00:00.000Z" };
+    const macro = (updated_at: string) =>
+      ({
+        id: updated_at,
+        kind: "prd",
+        title: "Macro",
+        parent_id: null,
+        lifecycle_status: "active",
+        work_status: "executing",
+        created_at: updated_at,
+        updated_at,
+        finished_at: null,
+        task_count: 0,
+        total_tokens: null,
+        cost: null,
+      }) as unknown as Parameters<typeof macroInWindow>[0];
+
+    expect(taskCountsInWindow([activeToday, activeYesterday, olderActive], today).total).toBe(1);
+    expect(taskCountsInWindow([activeToday, activeYesterday, olderActive], yesterday).total).toBe(
+      1,
+    );
+    expect(macroInWindow(macro(activeToday.updated_at), today)).toBe(true);
+    expect(macroInWindow(macro(activeToday.updated_at), yesterday)).toBe(false);
+    expect(macroInWindow(macro(activeYesterday.updated_at), yesterday)).toBe(true);
+    expect(macroInWindow(macro(olderActive.updated_at), today)).toBe(false);
+  });
+});