@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/operations/src/react/work-board-model.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { DashboardTaskProjection, MacroProjection } from "../contracts.js";
+import { macroWorkStage as sharedMacroWorkStage } from "../work-board-model.js";
 import {
   isWorkItemVisible,
   macroWorkProgress,
@@ -26,9 +27,9 @@ describe("unified work board stages", () => {
   });
 
   it.each([
-    ["draft", "SPEC-1", null],
+    ["draft", "SPEC-1", "definition"],
     ["planned", "SPEC-1", "ready"],
-    ["draft", null, null],
+    ["draft", null, "definition"],
     ["executing", null, "executing"],
     ["verifying", null, "verifying"],
     ["completed", null, "completed"],
@@ -57,7 +58,7 @@ describe("unified work board stages", () => {
         execution_started: false,
       }),
     ).toBe("ready");
-    expect(taskWorkStage({ status: "draft", spec_id: null })).toBeNull();
+    expect(taskWorkStage({ status: "draft", spec_id: null })).toBe("definition");
     expect(taskWorkStage({ status: "planned", spec_id: "SPEC-1" })).toBe("ready");
   });
 
@@ -130,6 +131,7 @@ describe("unified work board stages", () => {
     const row = { ...macro("spec", "active", "executing"), task_ids: ["TASK-1"] };
     const tasks = [{ id: "TASK-1", status: "verifying" }] as DashboardTaskProjection[];
     expect(macroWorkStage(row, tasks)).toBe("verifying");
+    expect(sharedMacroWorkStage(row, tasks)).toBe("verifying");
   });
 
   it("keeps an active macro in Execution while its Codex thread is running", () => {

package/templates/.agents/dashboard/modules/operations/src/react/work-board-model.ts

@@ -1,4 +1,8 @@
 import type { DashboardTaskProjection, MacroProjection } from "../contracts.js";
+
+export { macroWorkStage, taskWorkStage, type WorkStage, workStages } from "../work-board-model.js";
+
+import { macroWorkStage, taskWorkStage, type WorkStage, workStages } from "../work-board-model.js";
 import type { OperationsLocale } from "./status-labels.js";
 
 export type WorkTypeFilter = "all" | "prd" | "spec" | "task" | "standalone-task";
@@ -15,29 +19,6 @@ export interface MacroWorkProgress {
   totalTasks: number;
 }
 
-export type WorkStage =
-  | "definition"
-  | "planning"
-  | "ready"
-  | "executing"
-  | "verifying"
-  | "completed"
-  | "blocked"
-  | "cancelled"
-  | "failed";
-
-export const workStages: readonly WorkStage[] = [
-  "definition",
-  "planning",
-  "ready",
-  "executing",
-  "verifying",
-  "completed",
-  "blocked",
-  "cancelled",
-  "failed",
-];
-
 export function isWorkItemVisible(item: WorkItemIdentity, typeFilter: WorkTypeFilter): boolean {
   if (typeFilter === "task") return item.kind === "task";
   if (typeFilter === "standalone-task") return item.kind === "task" && item.row.spec_id === null;
@@ -117,63 +98,3 @@ export function workStageLabel(stage: WorkStage, locale: OperationsLocale): stri
   };
   return labels[locale][stage];
 }
-
-export function taskWorkStage(
-  task: Pick<DashboardTaskProjection, "status" | "spec_id"> &
-    Partial<
-      Pick<
-        DashboardTaskProjection,
-        "attempt_count" | "started_at" | "execution_started" | "is_active"
-      >
-    >,
-): WorkStage | null {
-  // A lingering local invocation must never revive a terminal Task in the board.
-  if (task.status === "completed") return "completed";
-  if (task.status === "cancelled") return "cancelled";
-  if (task.status === "failed") return "failed";
-  if (task.status === "blocked") return "blocked";
-  if (task.is_active === true) return "executing";
-  if (task.status === "executing") return "executing";
-  if (task.status === "verifying") return "verifying";
-  if ((task.attempt_count ?? 0) > 0 || task.started_at != null || task.execution_started === true) {
-    return "executing";
-  }
-  if (task.status === "planned") return "ready";
-  return null;
-}
-
-export function macroWorkStage(
-  row: MacroProjection,
-  tasks: readonly DashboardTaskProjection[],
-): WorkStage {
-  // Macro lifecycle is canonical. Derived conversation/execution status must
-  // not demote a draft, ready, or terminal PRD/SPEC to another board column.
-  if (row.lifecycle_status === "cancelled") return "cancelled";
-  if (row.lifecycle_status === "failed") return "failed";
-  if (row.lifecycle_status === "blocked") return "blocked";
-  if (row.lifecycle_status === "delivered" || row.lifecycle_status === "completed")
-    return "completed";
-  if (row.lifecycle_status === "ready") return "ready";
-  if (row.kind === "prd" && row.lifecycle_status === "draft") return "definition";
-  if (row.kind === "spec" && row.lifecycle_status === "draft") return "planning";
-  if (row.work_status === "cancelled") return "cancelled";
-  if (row.work_status === "failed") return "failed";
-  if (row.work_status === "blocked") return "blocked";
-  if (row.work_status === "completed") return "completed";
-  if (row.is_active || tasks.some((task) => row.task_ids.includes(task.id) && task.is_active)) {
-    return "executing";
-  }
-  if (row.lifecycle_status === "verifying" || row.work_status === "verifying") return "verifying";
-  if (row.work_status === "executing") {
-    const childTasks = tasks.filter((task) => row.task_ids.includes(task.id));
-    if (
-      childTasks.some((task) => task.status === "verifying") &&
-      childTasks.every((task) => task.status === "verifying" || task.status === "completed")
-    ) {
-      return "verifying";
-    }
-    return "executing";
-  }
-  if (row.lifecycle_status === "active") return "executing";
-  return "planning";
-}

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

@@ -1,16 +1,56 @@
 import { describe, expect, it } from "vitest";
+import { LEGACY_EFFORT_DAILY_MS } from "../contracts.js";
 import {
   createDescendantQueries,
+  deliveredMacroCounts,
   effectiveOperationsDurationMs,
   latestObservedSourceTiming,
+  observedMacroRunTelemetry,
   observedSourceTiming,
   overviewMetricTotals,
   projectExecutionDurations,
 } from "./build-operations-projection.js";
+import { projectCanonicalRun } from "./canonical-run-projection.js";
+import { normalizeFilter } from "./filter.js";
 import type { ScopedRun } from "./internal.js";
 import { macroProjection } from "./macro.js";
+import { aggregateOverviewRunMetrics } from "./quick-operations-projection.js";
 
 describe("execution duration projection", () => {
+  it("does not let a subrun or non-execution phase inflate overview duration", () => {
+    const base = {
+      started_at: "2026-08-07T12:00:00.000Z",
+      duration_ms: 0,
+      usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+    };
+    const duration = overviewMetricTotals(
+      [
+        {
+          ...base,
+          id: "RUN-ROOT",
+          phase: "execution",
+          parent_run_id: null,
+          source_duration_ms: 3_600_000,
+        },
+        {
+          ...base,
+          id: "RUN-CHILD",
+          phase: "execution",
+          parent_run_id: "RUN-ROOT",
+          source_duration_ms: 7_200_000,
+        },
+        {
+          ...base,
+          id: "RUN-PLAN",
+          phase: "planning",
+          parent_run_id: null,
+          source_duration_ms: 9_000_000,
+        },
+      ],
+      { from: "2026-08-07", to: "2026-08-07" },
+    ).duration_ms;
+    expect(duration).toBe(3_600_000);
+  });
   it("keeps duration unavailable without source telemetry", () => {
     const base = {
       agent: "zaip-agent-builder",
@@ -61,28 +101,172 @@ describe("execution duration projection", () => {
       projectExecutionDurations([
         { ...base, id: "RUN-LEGACY", duration_ms: 60_000, duration_provenance: "legacy_inferred" },
       ] as never)[0],
-    ).toMatchObject({
-      duration_ms: 60_000,
-      duration_provenance: "legacy_inferred",
-    });
+    ).toMatchObject({ duration_ms: 60_000, duration_provenance: "legacy_inferred" });
   });
 });
 
 describe("overview metrics", () => {
-  it("keeps overview totals equal to the full Run population without shipping its rows", () => {
+  it.each([
+    ["today", { from: "2026-08-08", to: "2026-08-08" }],
+    ["yesterday", { from: "2026-08-07", to: "2026-08-07" }],
+    ["this-week", { from: "2026-08-03", to: "2026-08-08" }],
+    ["last-week", { from: "2026-07-27", to: "2026-08-02" }],
+    ["this-month", { from: "2026-08-01", to: "2026-08-08" }],
+    ["last-month", { from: "2026-07-01", to: "2026-07-31" }],
+    ["last-3-months", { from: "2026-05-08", to: "2026-08-08" }],
+    ["last-6-months", { from: "2026-02-08", to: "2026-08-08" }],
+    ["this-year", { from: "2026-01-01", to: "2026-08-08" }],
+    ["last-year", { from: "2025-01-01", to: "2025-12-31" }],
+    ["custom", { from: "2026-08-07", to: "2026-08-08" }],
+    ["all", { from: null, to: null }],
+  ] as const)("keeps quick and detail duration, tokens, and cost equal for %s", (_preset, request) => {
+    const filter = normalizeFilter(request);
+    const runs = [
+      {
+        ...overviewRun("RUN-CROSS-MIDNIGHT", "2026-08-07T02:30:00.000Z", 3_600_000, 100, 1),
+        finished_at: "2026-08-07T03:30:00.000Z",
+      },
+      {
+        ...overviewRun("RUN-CROSS-MONTH", "2026-08-01T02:30:00.000Z", 2 * 3_600_000, 200, 2),
+        finished_at: "2026-08-01T04:30:00.000Z",
+      },
+      {
+        ...overviewRun("RUN-MISSING", "2026-08-07T12:00:00.000Z", 0, 0, 0),
+        source_duration_ms: null,
+        duration_ms: null,
+        usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+        finished_at: "2026-08-07T12:10:00.000Z",
+      },
+      {
+        ...overviewRun("RUN-ACTIVE", "2026-08-08T12:00:00.000Z", 60_000, 50, 0.5),
+        finished_at: null,
+      },
+    ];
+    const selected = runs.filter((run) => {
+      const timestamp = run.finished_at ?? run.started_at;
+      return (
+        (filter.from === null || timestamp >= filter.from) &&
+        (filter.to === null || timestamp <= filter.to)
+      );
+    });
+    const quick = aggregateOverviewRunMetrics(
+      runs.map((run) => ({
+        id: run.id,
+        started_at: run.started_at,
+        finished_at: run.finished_at,
+        phase: run.phase,
+        parent_run_id: run.parent_run_id,
+        duration_ms: run.source_duration_ms,
+        total_tokens: run.usage.total.tokens.total,
+        cost: run.usage.total.cost.brl,
+      })),
+      filter,
+    );
+    const detail = overviewMetricTotals(selected, filter);
+
+    expect(quick).toMatchObject({
+      duration_ms: detail.duration_ms,
+      tokens: detail.tokens,
+      cost_brl: detail.cost_brl,
+    });
+  });
+
+  it("adds eligible legacy baseline and post-cutoff observed roots without double counting", () => {
+    const filter = normalizeFilter({ from: "2026-07-01", to: "2026-08-08" });
+    const observed = overviewRun("RUN-POST-CUTOFF", "2026-08-07T12:00:00.000Z", 3_600_000, 10, 1);
+    const quick = aggregateOverviewRunMetrics(
+      [observed, observed].map((run) => ({
+        id: run.id,
+        started_at: run.started_at,
+        phase: run.phase,
+        parent_run_id: run.parent_run_id,
+        duration_ms: run.source_duration_ms,
+        total_tokens: run.usage.total.tokens.total,
+        cost: run.usage.total.cost.brl,
+      })),
+      filter,
+    );
+    const detail = overviewMetricTotals([observed], filter);
+    const legacy = Object.entries(LEGACY_EFFORT_DAILY_MS)
+      .filter(([day]) => day >= "2026-07-01" && day <= "2026-08-08")
+      .reduce((total, [, duration]) => total + duration, 0);
+
+    expect(quick).toMatchObject({ duration_ms: legacy + 3_600_000, tokens: 10, cost_brl: 1 });
+    expect(detail).toMatchObject({ duration_ms: legacy + 3_600_000, tokens: 10, cost_brl: 1 });
+  });
+
+  it("keeps a start-before, finish-inside Run's tokens and cost in quick and detail", () => {
+    const filter = normalizeFilter({ from: "2026-08-08", to: "2026-08-08" });
+    const crossing = {
+      ...overviewRun("RUN-FINISHES-INSIDE", "2026-08-07T23:50:00.000Z", 20 * 60_000, 42, 4.2),
+      finished_at: "2026-08-08T03:10:00.000Z",
+    };
+    const quick = aggregateOverviewRunMetrics(
+      [
+        {
+          id: crossing.id,
+          started_at: crossing.started_at,
+          finished_at: crossing.finished_at,
+          phase: crossing.phase,
+          parent_run_id: crossing.parent_run_id,
+          duration_ms: crossing.source_duration_ms,
+          total_tokens: crossing.usage.total.tokens.total,
+          cost: crossing.usage.total.cost.brl,
+        },
+      ],
+      filter,
+    );
+    const detail = overviewMetricTotals([crossing], filter);
+
+    expect(quick).toMatchObject({ tokens: 42, cost_brl: 4.2 });
+    expect(detail).toMatchObject({ tokens: 42, cost_brl: 4.2 });
+  });
+  it("counts delivered PRD and SPEC macros while Tasks use completed", () => {
+    const macros = deliveredMacroCounts(
+      [{ status: "delivered" }, { status: "active" }] as never,
+      [{ status: "delivered" }, { status: "delivered" }, { status: "ready" }] as never,
+    );
+    const tasks = [{ status: "completed" }, { status: "executing" }];
+
+    expect(macros).toEqual({ prds: 1, specs: 2 });
+    expect(tasks.filter((task) => task.status === "completed")).toHaveLength(1);
+  });
+
+  it("uses the root execution's observed duration when a filtered child is also visible", () => {
     const runs = [
-      overviewRun("RUN-ROOT", "2026-08-03T02:30:00.000Z", 120_000, 30, 1.5),
-      overviewRun("RUN-CHILD", "2026-08-03T04:30:00.000Z", 60_000, 10, 0.5, "RUN-ROOT"),
+      overviewRun("RUN-ROOT", "2026-08-03T04:30:00.000Z", 120_000, 30, 1.5),
+      overviewRun("RUN-CHILD", "2026-08-03T05:30:00.000Z", 60_000, 10, 0.5, "RUN-ROOT"),
     ];
-    const metrics = overviewMetricTotals(runs, false);
+    const metrics = overviewMetricTotals(runs, {
+      from: "2026-08-03T03:00:00.000Z",
+      to: "2026-08-04T02:59:59.999Z",
+    });
 
     expect(metrics).toEqual({
-      duration_ms: 180_000,
+      duration_ms: 120_000,
       execution_day_count: 1,
       tokens: 40,
       cost_brl: 2,
     });
-    expect(overviewMetricTotals(runs, true).duration_ms).toBe(229_466_186);
+    expect(overviewMetricTotals(runs, { from: "2026-08-03", to: "2026-08-03" }).duration_ms).toBe(
+      120_000,
+    );
+  });
+
+  it("counts repeated and overlapping source intervals only once", () => {
+    const first = overviewRun("RUN-1", "2026-08-03T12:00:00.000Z", 3_600_000, 30, 1.5);
+    const repeated = {
+      ...overviewRun("RUN-2", "2026-08-03T12:30:00.000Z", 3_600_000, 10, 0.5),
+      source_started_at: first.started_at,
+    };
+
+    expect(
+      overviewMetricTotals([first, repeated], { from: "2026-08-03", to: "2026-08-03" }),
+    ).toMatchObject({
+      duration_ms: 3_600_000,
+      tokens: 40,
+      cost_brl: 2,
+    });
   });
 });
 
@@ -167,7 +351,7 @@ describe("effective operations duration", () => {
 
   it("keeps duration unavailable instead of falling back to lifecycle wall time", () => {
     expect(effectiveOperationsDurationMs(null, 74 * 60 * 60_000)).toBeNull();
-    expect(effectiveOperationsDurationMs(0, 74 * 60 * 60_000)).toBeNull();
+    expect(effectiveOperationsDurationMs(0, 74 * 60 * 60_000)).toBe(0);
     expect(effectiveOperationsDurationMs(null, null)).toBeNull();
   });
 });
@@ -256,8 +440,100 @@ describe("latest observed source timing", () => {
   });
 });
 
-describe("macro wall time", () => {
-  it("counts only root Run wall-time for PRD and SPEC projections", () => {
+describe("macro duration", () => {
+  it("keeps canonical legacy duration through macro telemetry and rejects non-factual provenance", () => {
+    const scoped = (provenance: "legacy_inferred" | "estimated" | "unavailable"): ScopedRun =>
+      ({
+        artifactPath: "run.json",
+        cost: {
+          run: {
+            run_id: `RUN-${provenance}`,
+            attribution_status: "attributed",
+            conversation_id: "CONV",
+            execution_id: null,
+            task_id: null,
+            spec_id: null,
+            prd_id: null,
+            change_id: null,
+            work_type: "new",
+          },
+          records: [],
+          effective_usage_records: [],
+        } as unknown as ScopedRun["cost"],
+        fold: {
+          run: {
+            run_id: `RUN-${provenance}`,
+            occurred_at: "2026-08-08T03:00:00.000Z",
+            phase: "execution",
+            entrypoint: "task",
+            work_type: "new",
+            parent_run_id: null,
+            client: "codex",
+            agent: "agent-builder",
+            agent_name: null,
+            provider: null,
+            model: "gpt-5.6",
+            reasoning_effort: null,
+            conversation_id: "CONV",
+            execution_id: null,
+            task_id: null,
+            spec_id: null,
+            prd_id: null,
+            change_id: null,
+          },
+          finished: {
+            occurred_at: "2026-08-08T03:01:00.000Z",
+            duration_ms: 60_000,
+            duration_provenance: provenance,
+          },
+          status: "completed",
+          records: [],
+          effective_usage_records: [],
+          model_selection_records: [],
+          provider_invocation_records: [],
+        },
+      }) as unknown as ScopedRun;
+    const legacy = projectCanonicalRun(scoped("legacy_inferred"));
+    expect(legacy).toMatchObject({
+      duration_ms: 60_000,
+      duration_provenance: "legacy_inferred",
+      source_duration_ms: null,
+    });
+    expect(observedMacroRunTelemetry([legacy]).observedLifecycleDuration).toBe(60_000);
+    for (const provenance of ["estimated", "unavailable"] as const)
+      expect(projectCanonicalRun(scoped(provenance)).duration_ms).toBeNull();
+  });
+  it("deduplicates canonical Run IDs and unions only observed execution roots", () => {
+    const left = overviewRun("RUN-LEFT", "2026-08-07T12:00:00.000Z", 3_600_000, 0, 0);
+    const telemetry = observedMacroRunTelemetry([
+      left,
+      left,
+      overviewRun("RUN-RIGHT", "2026-08-07T12:30:00.000Z", 3_600_000, 0, 0),
+      {
+        ...overviewRun("RUN-UNKNOWN", "2026-08-07T14:00:00.000Z", 0, 0, 0),
+        source_duration_ms: null,
+        duration_ms: null,
+        duration_provenance: "unavailable",
+      },
+      overviewRun("RUN-CHILD", "2026-08-07T12:31:00.000Z", 99_000, 0, 0, "RUN-LEFT"),
+    ] as unknown as Parameters<typeof observedMacroRunTelemetry>[0]);
+
+    expect(telemetry.canonicalRuns.map((run) => run.id).sort()).toEqual([
+      "RUN-CHILD",
+      "RUN-LEFT",
+      "RUN-RIGHT",
+      "RUN-UNKNOWN",
+    ]);
+    expect(telemetry.rootExecutionRuns.map((run) => run.id).sort()).toEqual([
+      "RUN-LEFT",
+      "RUN-RIGHT",
+      "RUN-UNKNOWN",
+    ]);
+    expect(telemetry.observedRootDuration).toBe(5_400_000);
+    expect(telemetry.knownRootRuns).toHaveLength(2);
+  });
+
+  it("does not turn root Run lifecycle elapsed time into macro analytics", () => {
     const input = {
       id: "SPEC-1",
       title: "Spec",
@@ -275,8 +551,8 @@ describe("macro wall time", () => {
       tasks: new Map(),
     };
 
-    expect(macroProjection(input).duration_ms).toBe(60_000);
-    expect(macroProjection({ ...input, kind: "prd", parentId: null }).duration_ms).toBe(60_000);
+    expect(macroProjection(input).duration_ms).toBeNull();
+    expect(macroProjection({ ...input, kind: "prd", parentId: null }).duration_ms).toBeNull();
   });
 });