@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-summary-projection.ts

@@ -54,7 +54,8 @@ export function buildCostSummaryProjection(
     });
   const hasRunMetrics = summary.run_metrics !== undefined;
   const hasCanonicalSqliteFacts =
-    summary.cost_monitor_daily_duration !== undefined || summary.canonical_daily_duration_ms !== undefined;
+    summary.cost_monitor_daily_duration !== undefined ||
+    summary.canonical_daily_duration_ms !== undefined;
   // The SQLite path is fully sourced from canonical Run facts. Legacy daily
   // buckets remain available only to the old manifest path.
   const dailyPeriods = new Map<string, PeriodSummary>(
@@ -109,7 +110,10 @@ export function buildCostSummaryProjection(
     0,
   );
   const normalizedDurationBudget =
-    !hasRunMetrics && !hasCanonicalSqliteFacts && operations.filters.from === null && operations.filters.to === null
+    !hasRunMetrics &&
+    !hasCanonicalSqliteFacts &&
+    operations.filters.from === null &&
+    operations.filters.to === null
       ? canonicalAllTimeDurationMs(durationBudget)
       : durationBudget;
   const factualDailyRows = new Map(
@@ -131,12 +135,14 @@ export function buildCostSummaryProjection(
   const eventCount = daily.reduce((total, row) => total + row.event_count, 0);
   // A completely unavailable population must not become a factual zero merely
   // because the daily structural accumulator starts at zero.
-  const tokenTotal = !hasCanonicalSqliteFacts && compactRuns.every((run) => run.usage.total.tokens.total === null)
-    ? null
-    : sumNullable(daily.map((row) => row.total_tokens));
-  const brlTotal = !hasCanonicalSqliteFacts && compactRuns.every((run) => run.usage.total.cost.brl === null)
-    ? null
-    : sumNullable(daily.map((row) => row.estimated_brl));
+  const tokenTotal =
+    !hasCanonicalSqliteFacts && compactRuns.every((run) => run.usage.total.tokens.total === null)
+      ? null
+      : sumNullable(daily.map((row) => row.total_tokens));
+  const brlTotal =
+    !hasCanonicalSqliteFacts && compactRuns.every((run) => run.usage.total.cost.brl === null)
+      ? null
+      : sumNullable(daily.map((row) => row.estimated_brl));
   const usdTotal = sumNullable(daily.map((row) => row.estimated_usd));
   const observedDurationAverage = averageObservedPostCutoffRootDuration(summary.run_metrics ?? []);
   const taskCount =
@@ -156,9 +162,13 @@ export function buildCostSummaryProjection(
     readonly: true,
     source: ".agents/records",
     aggregate_only: true,
-    data_source: hasRunMetrics || hasCanonicalSqliteFacts ? "run_records" : "lifecycle_manifest_summary",
+    data_source:
+      hasRunMetrics || hasCanonicalSqliteFacts ? "run_records" : "lifecycle_manifest_summary",
     legacy_effort_baseline:
-      !hasRunMetrics && !hasCanonicalSqliteFacts && operations.filters.from === null && operations.filters.to === null
+      !hasRunMetrics &&
+      !hasCanonicalSqliteFacts &&
+      operations.filters.from === null &&
+      operations.filters.to === null
         ? { cutoff: LEGACY_EFFORT_SNAPSHOT.cutoff, duration_ms: LEGACY_EFFORT_SNAPSHOT.durationMs }
         : null,
     currency,
@@ -390,7 +400,8 @@ function effectiveSummaryRun(
     return {
       ...run,
       duration_provenance: run.duration_provenance ?? "unavailable",
-      estimation_basis: run.duration_provenance === "estimated" ? run.estimation_basis ?? null : null,
+      estimation_basis:
+        run.duration_provenance === "estimated" ? (run.estimation_basis ?? null) : null,
     };
   const duration_ms = estimatedDurationMs(run.total_tokens);
   return duration_ms === null
@@ -440,8 +451,7 @@ function normalizeTokenBackedGroupBudget(
 ): CostGroupRow[] {
   return normalizeTokenBackedDailyDuration(rows, budget).map((row) => ({
     ...row,
-    duration_ms:
-      row.duration.complete ? row.duration.known_sum : null,
+    duration_ms: row.duration.complete ? row.duration.known_sum : null,
   }));
 }
 
@@ -568,8 +578,7 @@ function periodRow(
     // counters report an incomplete financial population. Hiding it as
     // unavailable breaks parity with Operations and discards calculable time.
     // This is never model-inference latency or a token estimate.
-    duration_ms:
-      duration.population.known_runs > 0 ? duration.value.known_sum : null,
+    duration_ms: duration.population.known_runs > 0 ? duration.value.known_sum : null,
     duration: duration.value,
     coverage: {
       events: period.runs,

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-summary-terminal-day.test.ts

@@ -84,7 +84,12 @@ describe("Cost summary terminal-day accounting", () => {
         row,
       ]),
     );
-    expect(daily["2026-08-06"]).toMatchObject({ task_count: 4, run_count: 1, total_tokens: 100, estimated_brl: 10 });
+    expect(daily["2026-08-06"]).toMatchObject({
+      task_count: 4,
+      run_count: 1,
+      total_tokens: 100,
+      estimated_brl: 10,
+    });
     expect(daily["2026-08-07"]).toMatchObject({
       task_count: 5,
       run_count: 1,

package/templates/.agents/dashboard/modules/cost-monitor/src/server/source-size-cost-server/build-cost-monitor-projection-agents.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { buildCostMonitorProjection } from "../build-cost-monitor-projection.js";
+import { operationsWithPricedRun } from "../build-cost-monitor-projection.test-fixtures.js";
+
+describe("Cost Monitor V2 agent identity projection", () => {
+  it("uses the catalog agent id for Sub-Runs even when their inherited name is stale", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    source.agent = "agent-finalizer";
+    source.agent_name = "zaip-agent-orchestrator";
+    source.run_kind = "subrun";
+    source.parent_run_id = "RUN-PARENT";
+    const projection = buildCostMonitorProjection(operations, undefined, {
+      agentNamesById: { "agent-finalizer": "zaip-agent-finalizer" },
+    });
+    expect(projection.runs[0]?.agent_name).toBe("zaip-agent-finalizer");
+  });
+
+  it("maps an unmapped orchestrator internal id through its catalog role", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    source.agent = "orchestrator";
+    source.agent_name = "orchestrator";
+    const projection = buildCostMonitorProjection(operations, undefined, {
+      agentNamesByRole: { orchestrator: "zaip-agent-orchestrator" },
+    });
+    expect(projection.runs[0]?.agent_name).toBe("zaip-agent-orchestrator");
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/server/source-size-cost-server/build-cost-summary-projection-duration.test.ts

@@ -0,0 +1,414 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "../build-cost-summary-projection.js";
+
+describe("buildCostSummaryProjection duration aggregation", () => {
+  it("unions overlapping root execution intervals like Operations", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-07": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 2,
+            usage: {
+              total_tokens: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+              cost: {
+                known_sum: 0,
+                unknown: 2,
+                complete: false,
+                coverage_ratio: 0,
+                currency: "BRL",
+              },
+            },
+            duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "LEFT",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          duration_started_at: "2026-08-07T12:00:00.000Z",
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "RIGHT",
+          started_at: "2026-08-07T12:30:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          duration_started_at: "2026-08-07T12:30:00.000Z",
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    expect(
+      buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily[0]?.duration
+        .known_sum,
+    ).toBe(5_400_000);
+  });
+
+  it("keeps canonical root coverage without injecting the legacy baseline", () => {
+    const period = (runs: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0 },
+        cost: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0, currency: "BRL" },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-02": {
+            ...period(2),
+            duration: { known_sum: 2_000, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+          "2026-08-03": {
+            ...period(1),
+            duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "PRE",
+          started_at: "2026-08-02T03:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 99_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "POST",
+          started_at: "2026-08-02T04:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 2_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "UNKNOWN",
+          started_at: "2026-08-03T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+      canonical_daily_duration_ms: { "2026-08-02": 101_000 },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
+    const cutoffDay = projection.groups.daily.find((row) => row.key === "2026-08-02")!;
+    const unknownDay = projection.groups.daily.find((row) => row.key === "2026-08-03")!;
+
+    expect(cutoffDay).toMatchObject({
+      run_count: 2,
+      duration: {
+        known_sum: 101_000,
+        unknown: 0,
+        coverage_ratio: 1,
+      },
+      coverage_counts: {
+        metrics: { duration: { eligible_runs: 2, known_runs: 2, unknown_runs: 0 } },
+      },
+    });
+    expect(projection.groups.daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(
+      101_000,
+    );
+    expect(unknownDay.duration).toMatchObject({
+      known_sum: 0,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    expect(projection.groups.monthly.find((row) => row.key === "2026-08")?.duration).toMatchObject({
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    expect(
+      projection.groups.monthly.find((row) => row.key === "2026-08")?.coverage_counts?.metrics
+        ?.duration,
+    ).toEqual({
+      eligible_runs: 2,
+      known_runs: 2,
+      unknown_runs: 0,
+    });
+    expect(projection.overview.average_run_duration_ms).toBe(2_000);
+    expect(projection.legacy_effort_baseline).toBeNull();
+
+    const filtered = buildCostSummaryProjection(
+      summary,
+      { ...operations, filters: { from: "2026-08-03", to: "2026-08-03" } },
+      "BRL",
+      null,
+    );
+    expect(filtered.legacy_effort_baseline).toBeNull();
+    expect(filtered.groups.daily).toHaveLength(1);
+  });
+
+  it("preserves each canonical SQLite day instead of redistributing duration by tokens", () => {
+    const period = (tokens: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: {
+        total_tokens: { known_sum: tokens, unknown: 0, complete: true, coverage_ratio: 1 },
+        cost: {
+          known_sum: 1,
+          unknown: 0,
+          complete: true,
+          coverage_ratio: 1,
+          currency: "BRL" as const,
+        },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-01": period(1_000),
+          "2026-08-02": period(9_000),
+        },
+      },
+      canonical_daily_duration_ms: {
+        "2026-08-01": 9_000,
+        "2026-08-02": 1_000,
+      },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+
+    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
+
+    expect(daily.find((row) => row.key === "2026-08-01")?.duration.known_sum).toBe(9_000);
+    expect(daily.find((row) => row.key === "2026-08-02")?.duration.known_sum).toBe(1_000);
+  });
+
+  it("uses São Paulo timestamp bounds for Cost daily labels and preserves the interval total", () => {
+    const period = () => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 0,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+        cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1, currency: "BRL" },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: Object.fromEntries(
+          [
+            "2026-08-02",
+            "2026-08-03",
+            "2026-08-04",
+            "2026-08-05",
+            "2026-08-06",
+            "2026-08-07",
+            "2026-08-08",
+          ].map((day) => [day, period()]),
+        ),
+      },
+      run_metrics: [
+        {
+          id: "LEFT",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "RIGHT",
+          started_at: "2026-08-07T12:30:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: "2026-08-02T03:00:00.000Z", to: "2026-08-08T02:59:59.999Z" },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    summary.periods.daily["2026-08-07"] = {
+      ...period(),
+      duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
+
+    expect(daily.map((row) => row.key)).not.toContain("2026-08-08");
+    expect(daily.map((row) => row.key)).toEqual(
+      expect.arrayContaining(["2026-08-02", "2026-08-07"]),
+    );
+    expect(daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(5_400_000);
+  });
+  it("keeps factual duration visible while retaining partial financial coverage", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = {
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 2,
+      usage: { total_tokens: known(100), cost: { ...known(10), currency: "BRL" } },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const partial = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-08-12": period } },
+        cost_monitor_daily_duration: {
+          "2026-08-12": { known_sum: 60_000, eligible_runs: 2, known_runs: 1 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups.daily[0]!;
+    expect(partial).toMatchObject({ total_tokens: 100, estimated_brl: 10, duration_ms: 60_000 });
+    expect(partial.duration).toMatchObject({ known_sum: 60_000, unknown: 1, complete: false });
+
+    const observedZero = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-08-12": { ...period, runs: 1 } } },
+        cost_monitor_daily_duration: {
+          "2026-08-12": { known_sum: 0, eligible_runs: 1, known_runs: 1 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups.daily[0]!;
+    expect(observedZero.duration_ms).toBe(0);
+  });
+  it("keeps monthly and annual duration unavailable when any financial day is incomplete", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = (tokens: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: { total_tokens: known(tokens), cost: { ...known(tokens), currency: "BRL" as const } },
+    });
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const groups = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-07-23": period(10), "2026-07-24": period(20) } },
+        cost_monitor_daily_duration: {
+          "2026-07-23": { known_sum: 20_000, eligible_runs: 1, known_runs: 1 },
+          "2026-07-24": { known_sum: 0, eligible_runs: 1, known_runs: 0 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups;
+    expect(groups.daily.map((row) => row.duration_ms)).toEqual([20_000, null]);
+    expect(groups.monthly[0]?.duration_ms).toBeNull();
+    expect(groups.annual[0]?.duration_ms).toBeNull();
+  });
+});

package/templates/.agents/dashboard/modules/operations/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-operations",
-  "version": "1.0.8",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/modules/operations/src/contracts.ts

@@ -153,7 +153,12 @@ export interface UsageProjection {
   rework: UsageMetricProjection;
 }
 
-export type MetricProvenance = "observed" | "reconciled" | "legacy_inferred" | "estimated";
+export type MetricProvenance =
+  | "observed"
+  | "reconciled"
+  | "legacy_inferred"
+  | "shared_creation_allocation"
+  | "estimated";
 
 export interface MetricCoverageProjection {
   population: number;
@@ -231,7 +236,13 @@ export interface MacroProjection {
     unknown_runs: number;
     coverage_ratio: number;
   };
-  duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  duration_provenance?:
+    | "observed"
+    | "reconciled"
+    | "legacy_inferred"
+    | "shared_creation_allocation"
+    | "estimated"
+    | "unavailable";
   lifecycle_duration_coverage?: NonNullable<MacroProjection["duration_coverage"]>;
   lifecycle_duration_provenance?: MacroProjection["duration_provenance"];
   estimation_basis?: string | null;
@@ -380,7 +391,13 @@ export interface RunProjection {
   finished_at: string | null;
   duration_ms: number | null;
   duration_started_at?: string | null;
-  duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  duration_provenance?:
+    | "observed"
+    | "reconciled"
+    | "legacy_inferred"
+    | "shared_creation_allocation"
+    | "estimated"
+    | "unavailable";
   estimation_basis?: string | null;
   source_started_at?: string | null;
   source_finished_at?: string | null;
@@ -492,31 +509,34 @@ export interface OperationsProjection extends ReadonlyV2Projection {
         cost_brl: number | null;
         run_count: number;
       }>;
-      macro_metrics?: Record<"specs" | "prds", {
-        status_counts: Record<string, number>;
-        classification_counts: Record<string, number>;
-        entity_count: number;
-        total_run_count: number;
-        total_duration_ms: number | null;
-        total_tokens: number | null;
-        total_cost_usd?: number | null;
-        total_cost_brl: number | null;
-        average_duration_ms: number | null;
-        average_tokens: number | null;
-        average_cost_usd?: number | null;
-        average_cost_brl: number | null;
-        latest_created_at: string | null;
-        top_entities: Array<{
-          entity_id: string;
-          title: string;
-          duration_ms: number | null;
+      macro_metrics?: Record<
+        "specs" | "prds",
+        {
+          status_counts: Record<string, number>;
+          classification_counts: Record<string, number>;
+          entity_count: number;
+          total_run_count: number;
+          total_duration_ms: number | null;
           total_tokens: number | null;
           total_cost_usd?: number | null;
-          cost_brl: number | null;
-          run_count: number;
-          duration_share: number;
-        }>;
-      }>;
+          total_cost_brl: number | null;
+          average_duration_ms: number | null;
+          average_tokens: number | null;
+          average_cost_usd?: number | null;
+          average_cost_brl: number | null;
+          latest_created_at: string | null;
+          top_entities: Array<{
+            entity_id: string;
+            title: string;
+            duration_ms: number | null;
+            total_tokens: number | null;
+            total_cost_usd?: number | null;
+            cost_brl: number | null;
+            run_count: number;
+            duration_share: number;
+          }>;
+        }
+      >;
       latest_task_created_at?: string | null;
       coverage?: { duration: number; tokens: number; cost: number };
       data_source?: "lifecycle_manifest_summary" | "run_records";